@Override
public Long countConceptsAlignedToExtThes(String idThesaurus) {
DetachedCriteria alignmentCriteria =
DetachedCriteria.forClass(Alignment.class, "al")
.add(Restrictions.isNotNull("al.externalTargetThesaurus"))
.setProjection(
Projections.projectionList()
.add(Projections.property(AL_SOURCE_CONCEPT_IDENTIFIER)));
DetachedCriteria conceptCriteria =
DetachedCriteria.forClass(ThesaurusConcept.class, "stc")
.add(Restrictions.eq("stc.thesaurus.identifier", idThesaurus))
.setProjection(
Projections.projectionList().add(Projections.property("stc.identifier")));
Criteria criteria =
getCurrentSession()
.createCriteria(ThesaurusConcept.class, "tc")
.add(
Restrictions.and(
Subqueries.propertyIn(TC_IDENTIFIER, alignmentCriteria),
Subqueries.propertyIn(TC_IDENTIFIER, conceptCriteria)))
.setProjection(Projections.rowCount());
return (Long) criteria.list().get(0);
}
private Criteria getCriteriaByThesaurusAndTopConcept(
Thesaurus thesaurus, boolean topConcept, String like) {
Criteria criteria = getCurrentSession().createCriteria(ThesaurusConcept.class, "tc");
if (null != like) {
criteria =
getCurrentSession()
.createCriteria(ThesaurusTerm.class, "tt")
.add(Restrictions.isNotNull("tt.concept"))
.createCriteria("concept", "tc", JoinType.RIGHT_OUTER_JOIN);
criteria
.setProjection(
Projections.projectionList()
.add(Projections.property("tt.lexicalValue"))
.add(Projections.property("tc.identifier").as("identifier")))
.setResultTransformer(Transformers.aliasToBean(ThesaurusConcept.class));
conceptNameIsLike(criteria, like);
}
selectThesaurus(criteria, thesaurus.getIdentifier());
selectOrphans(criteria, !topConcept);
selectNoParents(criteria);
return criteria;
}
@SuppressWarnings("unchecked")
protected List<Object[]> getSavedSearchDetails(Long savedSearchQueryID, String type) {
SavedSearchRetriever.AlertType alertType = SavedSearchRetriever.AlertType.valueOf(type);
DetachedCriteria criteria =
DetachedCriteria.forClass(UserProfile.class)
.setProjection(
Projections.distinct(
Projections.projectionList()
.add(Projections.property("ss.ID"))
.add(Projections.property("email"))
.add(Projections.property("ss.searchName"))))
.createAlias("savedSearches", "ss")
.createAlias("ss.searchQuery", "q")
.add(Restrictions.eq("q.ID", savedSearchQueryID));
if (alertType == SavedSearchRetriever.AlertType.WEEKLY) {
criteria.add(Restrictions.eq("ss.weekly", true));
}
if (alertType == SavedSearchRetriever.AlertType.MONTHLY) {
criteria.add(Restrictions.eq("ss.monthly", true));
}
return (List<Object[]>) hibernateTemplate.findByCriteria(criteria);
}
public void prepareDateRange() throws Exception {
DetachedCriteria criteria = DetachedCriteria.forClass(ConfirmationRecord.class);
ProjectionList pjl = Projections.projectionList();
pjl.add(Projections.property("cycleFrom"));
pjl.add(Projections.property("cycleTo"));
criteria.setProjection(Projections.distinct(pjl));
List<?> list = confirmationRecordService.findByCriteria(criteria);
if (list.size() > 0) {
Object[] objs = list.toArray();
selectionCycleFrom = new ArrayList<>();
selectionCycleFrom.add(new SelectItem(null, "Please Select"));
cycleTos = new ArrayList<>();
for (Object obj : objs) {
if (obj instanceof Object[]) {
Object[] innerObjs = (Object[]) obj;
if (innerObjs.length == 2) {
Date dFrom = DateUtil.convStringToDate(MS_SQL_DATE_PATTERN, innerObjs[0].toString());
Date dTo = DateUtil.convStringToDate(MS_SQL_DATE_PATTERN, innerObjs[1].toString());
selectionCycleFrom.add(
new SelectItem(
DateUtil.convDateToString(SIMPLE_DATE_PATTERN, dFrom),
DateUtil.convDateToString(DISPLAY_DATE_PATTERN, dFrom)));
cycleTos.add(DateUtil.convDateToString(SIMPLE_DATE_PATTERN, dTo));
} else {
System.err.println("ERR: obj[] length not eq to 2");
}
}
}
}
}
@SuppressWarnings("unchecked")
private AnnotationView buildAnnotationView(Annotation annotation, boolean loadAllReplies) {
Object values[];
try {
values =
(Object[])
hibernateTemplate
.findByCriteria(
DetachedCriteria.forClass(Article.class)
.add(Restrictions.eq("ID", annotation.getArticleID()))
.setProjection(
Projections.projectionList()
.add(Projections.property("doi"))
.add(Projections.property("title"))),
0,
1)
.get(0);
} catch (IndexOutOfBoundsException e) {
// this should never happen
throw new IllegalStateException(
"Annotation "
+ annotation.getID()
+ " pointed to an article that didn't exist;"
+ " articleID: "
+ annotation.getArticleID());
}
String articleDoi = (String) values[0];
String articleTitle = (String) values[1];
return buildAnnotationView(annotation, articleDoi, articleTitle, loadAllReplies);
}
public List<SessionTimeOutDTO> getSessionIDListBySID(Long sid) {
List<SessionTimeOutDTO> dtoList = null;
SessionTimeOutDTO dto = null;
Session session = getSession();
session.getTransaction().begin();
Criteria criteria =
session
.createCriteria(SessionDetails.class, "sessionDetails")
.add(Restrictions.eq("SID", sid));
criteria.setProjection(
Projections.projectionList()
.add(Projections.property("SID").as("sid"))
.add(Projections.property("sessionId").as("sessionId")));
dto =
(SessionTimeOutDTO)
criteria
.setResultTransformer(Transformers.aliasToBean(SessionTimeOutDTO.class))
.uniqueResult();
session.getTransaction().commit();
session.close();
dtoList = getList(dto);
return dtoList;
}
@Override
@Transactional(readOnly = true)
public AnnotationView[] listAnnotationsNoReplies(
final Long articleID,
final Set<AnnotationType> annotationTypes,
final AnnotationOrder order) {
if (order == AnnotationOrder.MOST_RECENT_REPLY) {
throw new IllegalArgumentException(
"Cannot specify Most Recent Reply order type when replies are not being loaded up");
}
// Basic criteria
DetachedCriteria criteria =
DetachedCriteria.forClass(Annotation.class)
.add(Restrictions.eq("articleID", articleID))
.setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY);
// restrict by type
if (annotationTypes != null && !annotationTypes.isEmpty()) {
criteria.add(Restrictions.in("type", annotationTypes));
}
switch (order) {
case OLDEST_TO_NEWEST:
criteria.addOrder(Order.asc("created"));
break;
case NEWEST_TO_OLDEST:
criteria.addOrder(Order.desc("created"));
break;
}
List annotationResults = hibernateTemplate.findByCriteria(criteria);
// Don't want to call buildAnnotationView() here because that would involve finding the article
// title and doi for each annotation,
// when we only need to do it once. So load up the info we need to build annotation views here
Object[] articleTitleAndDoi;
try {
articleTitleAndDoi =
(Object[])
hibernateTemplate
.findByCriteria(
DetachedCriteria.forClass(Article.class)
.add(Restrictions.eq("ID", articleID))
.setProjection(
Projections.projectionList()
.add(Projections.property("doi"))
.add(Projections.property("title"))),
0,
1)
.get(0);
} catch (IndexOutOfBoundsException e) {
throw new IllegalArgumentException("article " + articleID + " didn't exist");
}
String articleDoi = (String) articleTitleAndDoi[0];
String articleTitle = (String) articleTitleAndDoi[1];
List<AnnotationView> viewResults = new ArrayList<AnnotationView>(annotationResults.size());
for (Object annotation : annotationResults) {
viewResults.add(new AnnotationView((Annotation) annotation, articleDoi, articleTitle, null));
}
return viewResults.toArray(new AnnotationView[viewResults.size()]);
}
@Scheduled(fixedDelay = 60000)
public void changeSessionStatus() {
List<CurrentUsersDTO> allList = null;
List<CurrentUsersDTO> activeList = null;
String currentTime = getTime();
String beforeTime = getBeforeTime();
String beforeHeartBeatTime = getBeforeHeartBeatTime();
Session session = getSession();
session.getTransaction().begin();
Criteria criteria =
session
.createCriteria(SessionDetails.class, "sessionDetails")
.add(
Restrictions.between(
"sessionDetails.heartBeatTime", beforeHeartBeatTime, currentTime))
.add(Restrictions.between("sessionDetails.lastAccessTime", beforeTime, currentTime));
criteria.addOrder(Order.asc("SID"));
criteria.setProjection(
Projections.projectionList()
.add(Projections.property("SID").as("sid"))
.add(Projections.property("lastAccessTime").as("lastAccessTime")));
activeList =
criteria.setResultTransformer(Transformers.aliasToBean(CurrentUsersDTO.class)).list();
Criteria criteria1 = session.createCriteria(SessionDetails.class, "sessionDetails");
criteria1.addOrder(Order.asc("SID"));
criteria1.setProjection(
Projections.projectionList()
.add(Projections.property("SID").as("sid"))
.add(Projections.property("lastAccessTime").as("lastAccessTime")));
allList =
criteria1.setResultTransformer(Transformers.aliasToBean(CurrentUsersDTO.class)).list();
for (CurrentUsersDTO dto : allList) {
try {
SessionDetails sd = getById(dto.getSid());
sd.setStatus("INACTIVE");
saveSessionDetails(sd);
} catch (Exception e) {
System.out.println("E :" + e);
}
}
for (CurrentUsersDTO dto : activeList) {
try {
SessionDetails sd = getById(dto.getSid());
sd.setStatus("ACTIVE");
saveSessionDetails(sd);
} catch (Exception e) {
System.out.println("E :" + e);
}
}
session.getTransaction().commit();
session.close();
}
public List<?> getLoginList() { // 获得管理员和密码的列表
DetachedCriteria criteria = DetachedCriteria.forClass(Admin.class);
criteria.setProjection(
(Projections.projectionList()
.add(Projections.property("name"))
.add(Projections.property("password"))));
List<?> list = getHibernateTemplate().findByCriteria(criteria);
return list;
}
// Create by JOB
public List<User> getAllUserTrainee() {
Criteria criteria = getSession().createCriteria(User.class);
criteria.setProjection(
Projections.projectionList()
.add(Projections.property("empId"), "empId")
.add(Projections.property("thFname"), "thFname")
.add(Projections.property("thLname"), "thLname"));
Criterion cri = Restrictions.eq("aptId", 1);
Criterion cri2 = Restrictions.eq("aptId", 2);
criteria.add(Restrictions.or(cri, cri2));
criteria.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
List<User> allUserTrainee = criteria.list();
return allUserTrainee;
}
@Override
@Transactional
public Long createReply(
UserProfile user, Long parentId, String title, String body, @Nullable String ciStatement) {
if (parentId == null) {
throw new IllegalArgumentException("Attempting to create reply with null parent id");
}
log.debug("Creating reply to {}; title: {}; body: {}", new Object[] {parentId, title, body});
Long articleID;
try {
articleID =
(Long)
hibernateTemplate
.findByCriteria(
DetachedCriteria.forClass(Annotation.class)
.add(Restrictions.eq("ID", parentId))
.setProjection(Projections.property("articleID")),
0,
1)
.get(0);
} catch (IndexOutOfBoundsException e) {
throw new IllegalArgumentException("Invalid annotation id: " + parentId);
}
Annotation reply = new Annotation(user, AnnotationType.REPLY, articleID);
reply.setParentID(parentId);
reply.setTitle(title);
reply.setBody(body);
reply.setCompetingInterestBody(ciStatement);
reply.setAnnotationUri(URIGenerator.generate(reply));
return (Long) hibernateTemplate.save(reply);
}
public List<UserCountDTO> getCurrentUserCountList(
String sortField, int order, int start, int gridTableSize, String searchq) throws Exception {
int count = start;
List<UserCountDTO> dtoList = null;
List<UserCountDTO> dtoListCount = new ArrayList<UserCountDTO>();
Session session = getSession();
session.getTransaction().begin();
Criteria criteria =
session
.createCriteria(SessionDetails.class, "sessionDetails")
.add(Restrictions.eq("status", "ACTIVE"));
criteria.addOrder(Order.asc("SID"));
criteria.setFirstResult(start).setMaxResults(gridTableSize);
criteria.setProjection(Projections.projectionList().add(Projections.property("SID").as("sid")));
dtoList = criteria.setResultTransformer(Transformers.aliasToBean(UserCountDTO.class)).list();
session.getTransaction().commit();
session.close();
if (dtoList.size() > 0) {
for (UserCountDTO dto : dtoList) {
dto.setCountId(count + 1);
dtoListCount.add(dto);
count += 1;
}
}
return dtoListCount;
}
@Override
public List<ThesaurusConcept> getPaginatedAvailableConceptsOfGroup(
Integer startIndex,
Integer limit,
String groupId,
String thesaurusId,
Boolean onlyValidatedConcepts,
String like) {
DetachedCriteria dc = DetachedCriteria.forClass(ThesaurusConceptGroup.class, "gr");
dc.createCriteria("concepts", "tc", JoinType.RIGHT_OUTER_JOIN);
dc.setProjection(Projections.projectionList().add(Projections.property("tc.identifier")));
dc.add(Restrictions.eq("gr.identifier", groupId));
Criteria criteria = selectPaginatedConceptsByAlphabeticalOrder(startIndex, limit);
criteria.add(Subqueries.propertyNotIn("tc.identifier", dc));
selectThesaurus(criteria, thesaurusId);
criteria.add(
Restrictions.not(
Restrictions.and(
Restrictions.eq("topConcept", false),
Restrictions.or(
Restrictions.isNull("tc.parentConcepts"),
Restrictions.isEmpty("tc.parentConcepts")))));
if (null != like) {
conceptNameIsLike(criteria, like);
}
onlyValidatedConcepts(criteria, onlyValidatedConcepts);
return criteria.list();
}
public List<Entidad> obtenerEntidadesYaPoliticas(Long idRed) {
List<Entidad> entidades =
this.criteriaEntidadesPoliticas(idRed)
.setProjection(Projections.projectionList().add(Projections.property("entidad")))
.list();
return entidades;
}
@SuppressWarnings("unchecked")
@Override
public Object tryAndFindLookupValue(
final String systemName,
final String tableName,
final String columnName,
final String lookupValue)
throws ClassNotFoundException {
final List<PhysicalToPhysicalLookupView> physicalLookups =
getSession()
.createCriteria(PhysicalToPhysicalLookupView.class)
.add(Restrictions.eq("id.systemName", systemName))
.add(Restrictions.eq("id.tableName", tableName))
.add(Restrictions.eq("id.columnNume", columnName))
.list();
if (physicalLookups == null || physicalLookups.size() != 2) {
// do nothing - return a warning if > 2
return null;
}
String lookupSystem = "";
String lookupTable = "";
String lookupColumn = "";
String projection = "";
for (final PhysicalToPhysicalLookupView lookup : physicalLookups) {
if (lookup.getId().getNameRuleType().equals(LOOKUP_KEY)) {
lookupSystem = lookup.getId().getSystemName();
lookupTable = lookup.getId().getLookupTable();
lookupColumn = lookup.getId().getLookupColumn();
}
if (lookup.getId().getNameRuleType().equals(LOOKUP_VALUE)) {
projection = lookup.getId().getLookupColumn();
}
}
if (lookupSystem == null || lookupTable == null || lookupColumn == null || projection == null) {
throw new RuntimeException(
"Unable to create a lookup map for system name: "
+ systemName
+ " on table "
+ tableName
+ " with column "
+ columnName);
}
final Class<?> clazz = null; // explorer.getClass(lookupTable,
// systemName.toLowerCase(),"com.equityopschange.systems");
final Object lookedUpValue =
getSession()
.createCriteria(clazz)
.add(Restrictions.eq(lookupColumn, lookupValue))
.setProjection(Projections.property(projection))
.uniqueResult();
return lookedUpValue;
}
@Override
public Long getCount(Retirement r, String ks, String js, String eq, String type) {
Criteria criteria = buildCondition(r, ks, js, eq, type);
ProjectionList proList = Projections.projectionList(); // 设置投影集合
proList.add(Projections.property("sfzh"));
criteria.setProjection(proList);
return this.getCount(criteria);
}
@SuppressWarnings("unchecked")
public List<String> listStringByFields(String field) {
Criteria criteria = getCurrentSession().createCriteria(Titem.class);
criteria.setProjection(Projections.distinct(Projections.property(field)));
criteria.addOrder(Order.asc(field));
List<String> list = criteria.list();
return list;
}
public Collection<String> getAllMacs() {
Criteria criteria = getSession().createCriteria(IpPoolManagement.class);
ProjectionList projList = Projections.projectionList();
projList.add(Projections.property(IpPoolManagement.MAC_PROPERTY));
criteria.setProjection(projList);
return criteria.list();
}
public static boolean checkIfEntityExists(
Session session, Class classz, String idKey, String idValue) {
return session
.createCriteria(classz)
.add(Restrictions.eq(idKey, idValue))
.setProjection(Projections.property(idKey))
.uniqueResult()
!= null;
}
@Override
@SuppressWarnings("unchecked")
public List<String> getFormNames(Person owner) {
DetachedCriteria criteria = DetachedCriteria.forClass(type);
criteria.setProjection(Projections.distinct(Projections.property("formName")));
if (owner != null) criteria.add(Restrictions.eq("person.personId", owner.getPersonId()));
return getHibernateTemplate().findByCriteria(criteria);
}
public static void main(String[] args) {
Session session = HibUtil.getSession();
Criteria crit = session.createCriteria(Employee.class);
crit.setProjection(Projections.property("empName"));
List<String> names = crit.list();
for (String name : names) {
System.out.println(name);
}
}
public List<String> getSharedListUserNames() {
DetachedCriteria criteria = DetachedCriteria.forClass(CustomSeriesList.class);
ProjectionList projectionList = Projections.projectionList();
projectionList.add(Projections.property("userName"));
criteria.setProjection(Projections.distinct(projectionList));
List<String> results = new ArrayList<String>();
results = getHibernateTemplate().findByCriteria(criteria);
return results;
}
@SuppressWarnings("unchecked")
public List<GraffitiDTO> getByWriteDate(Date writeDate) throws DataAccessException {
Criteria c =
getCurrentSession()
.createCriteria(Graffiti.class)
.createAlias("member", "member")
.add(Expression.ge("writeDate", writeDate))
.addOrder(Order.asc("writeDate"))
.setProjection(
Projections.projectionList()
.add(Projections.property("id").as("id"))
.add(Projections.property("member.name").as("writerName"))
.add(Projections.property("member.avatar").as("writerAvatar"))
.add(Projections.property("contents").as("contents"))
.add(Projections.property("writeDate").as("writtenDate")))
.setResultTransformer(new AliasToBeanResultTransformer(GraffitiDTO.class));
return c.list();
}
@SuppressWarnings("unchecked")
@Override
public ResultList getUnique(String key, String query) {
Criteria criteria = sessionFactory.getCurrentSession().createCriteria(PersonName.class);
criteria.add(Restrictions.ilike(key, query + "%"));
criteria.setProjection(Projections.distinct(Projections.property(key)));
criteria.setMaxResults(20);
return new ResultList(criteria.list());
}
@SuppressWarnings("unchecked")
@Override
public Collection<FuncionarioAreaTrabajoDTO> consultarFuncionarioAreaTrabajoPorAreaTrabajo(
Integer codigoAreaTrabajo, String userId, Integer codigoCompania, String usuarioSesion)
throws SICException {
try {
Criteria criteria =
sessionFactory.getCurrentSession().createCriteria(FuncionarioAreaTrabajoDTO.class);
criteria.setProjection(
Projections.projectionList()
.add(Projections.property("usuarioDTO.userId"), "funcionarioDTO.usuarioDTO.userId")
.add(
Projections.property("usuarioDTO.userCompleteName"),
"funcionarioDTO.usuarioDTO.userCompleteName")
.add(
Projections.property("usuarioDTO.userName"), "funcionarioDTO.usuarioDTO.userName")
.add(
Projections.property("areaTrabajoDTO.nombreAreaTrabajo"),
"areaTrabajoDTO.nombreAreaTrabajo")
.add(Projections.property("id.codigoCompania"), "id.codigoCompania")
.add(Projections.property("id.codigoFuncionario"), "id.codigoFuncionario")
.add(Projections.property("id.codigoAreaTrabajo"), "id.codigoAreaTrabajo"));
criteria.createAlias("funcionarioDTO", "funcionarioDTO");
criteria.createAlias("funcionarioDTO.usuarioDTO", "usuarioDTO");
criteria.createAlias("areaTrabajoDTO", "areaTrabajoDTO");
criteria.add(Restrictions.eq("estado", SICConstantes.ESTADO_ACTIVO_LITERAL));
criteria.add(
Restrictions.eq("funcionarioDTO.estadoFuncionario", SICConstantes.ESTADO_ACTIVO_LITERAL));
criteria.add(
Restrictions.eq("areaTrabajoDTO.estadoAreaTrabajo", SICConstantes.ESTADO_ACTIVO_LITERAL));
criteria.add(Restrictions.eq("id.codigoCompania", codigoCompania));
criteria.add(Restrictions.eq("areaTrabajoDTO.id.codigoAreaTrabajo", codigoAreaTrabajo));
criteria.add(Restrictions.ne("usuarioDTO.userName", usuarioSesion));
// si el usuario ingresa un nombre o usuario de un funcionario
if (StringUtils.isNotEmpty(userId)) {
Disjunction disjunction = Restrictions.disjunction();
disjunction.add(Restrictions.ilike("usuarioDTO.userName", userId, MatchMode.ANYWHERE));
disjunction.add(
Restrictions.ilike("usuarioDTO.userCompleteName", userId, MatchMode.ANYWHERE));
criteria.add(disjunction);
}
criteria.setResultTransformer(new DtoResultTransformer(FuncionarioAreaTrabajoDTO.class));
Collection<FuncionarioAreaTrabajoDTO> funcionarioAreaTrabajoDTOCol = criteria.list();
return funcionarioAreaTrabajoDTOCol;
} catch (HibernateException e) {
throw new SICException("Error consultarFuncionarioAreaTrabajoPorAreaTrabajo: ", e);
} catch (Exception e) {
throw new SICException("Error consultarFuncionarioAreaTrabajoPorAreaTrabajo ", e);
}
}
@SuppressWarnings("unchecked")
public List<String> getAllHomeDepartments(ObjectStatus status) {
Criteria criteria = createCriteria();
if (status != null) criteria.add(Restrictions.eq("objectStatus", status));
criteria.add(Restrictions.isNotNull("departmentName"));
criteria.setProjection(
Projections.projectionList()
.add(Projections.distinct(Projections.property("departmentName"))));
return ((List<String>) criteria.list());
}
public List<Facturador> obtenerFacturadoresHabilitados(Long idRed) {
HibernateEntityManager hem = (HibernateEntityManager) this.getEm().getDelegate();
List<Facturador> facturadores =
(List<Facturador>)
hem.getSession()
.createCriteria(HabilitacionFactRed.class)
.add(Restrictions.eq("red", new Red(idRed)))
.setProjection(Projections.projectionList().add(Projections.property("facturador")))
.list();
return facturadores;
}
@SuppressWarnings("unchecked")
@Override
public List<Integer> recuperarIdsOficinasDisponiveis(Integer idCursoSelecionado) {
Criteria criteria = getSession().createCriteria(Oficina.class);
if (idCursoSelecionado != null && !idCursoSelecionado.equals(0)) {
criteria.createAlias("curso", "curso");
criteria.add(Restrictions.eq("curso.id", idCursoSelecionado));
criteria.setProjection(Projections.distinct(Projections.property("id")));
}
return criteria.list();
}
@SuppressWarnings("unchecked")
@Override
public List<Oficina> listarOficinas(Integer idInscricaoCurso) {
Criteria criteria = getSession().createCriteria(Oficina.class);
DetachedCriteria subCriteria = DetachedCriteria.forClass(SelecaoOficina.class);
subCriteria.add(Property.forName("inscricaoCurso.id").eq(idInscricaoCurso));
subCriteria.setProjection(Projections.distinct(Projections.property("oficina.id")));
criteria.add(Property.forName("id").in(subCriteria));
return criteria.list();
}
public List<Long> findOrderIds(Object... params) {
Criteria criteria = createDefaultCriteria(OrderPurchase.class);
criteria.setProjection(Projections.property("id"));
handleSpecificOrderFetchMode(criteria, params);
criteria.addOrder(Order.asc("dateCreate"));
@SuppressWarnings("unchecked")
List<Long> orderIds = criteria.list();
return orderIds;
}
