public int getNumDocuments(String folderId) { DmFolder folder = null; if (folderId != null) { folder = new DmFolder(); folder.setId(folderId); } if (folder != null) { Disjunction disjunction = Restrictions.disjunction(); disjunction.add(Restrictions.isNull("docApproval.id")); disjunction.add( Restrictions.ne("docApproval.status", ApplicationConstants.APPROVAL_STATUS_REJECTED)); Criteria crit = getSession().createCriteria(DmDocumentFolder.class); crit.createAlias("document", "docInfo"); crit.createAlias("docInfo.approval", "docApproval", CriteriaSpecification.LEFT_JOIN); crit.add(Restrictions.eq("folder", folder)); // crit.add(Restrictions.eq("docInfo.approved", true)); crit.add(disjunction); return crit.list().size(); } return 0; }
public static Vector<Person> searchPerson(String keyword) { Session session = sf.openSession(); Criteria criteria = session.createCriteria(Person.class); keyword = keyword.trim(); Disjunction or = Restrictions.disjunction(); or.add(Restrictions.like("name", "%" + keyword + "%")); or.add(Restrictions.like("sex", "%" + keyword + "%")); or.add(Restrictions.like("born", "%" + keyword + "%")); or.add(Restrictions.like("year", "%" + keyword + "%")); or.add(Restrictions.like("day", "%" + keyword + "%")); criteria.add(or); Vector vt = new Vector(); List result = new Vector<Person>(); result = criteria.list(); for (Object o : result) { Person person = (Person) o; Vector temp = new Vector(); temp.add(person.getName()); temp.add(person.getSex()); temp.add(person.getBorn()); temp.add(person.getYear()); temp.add(person.getDay()); temp.add(person.getId()); temp.add(person.getIsdirector()); temp.add(person.getIsstar()); vt.add(temp); } return vt; }
@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); } }
@Override public Map<String, Object> lista(Map<String, Object> params) { log.debug("Buscando lista de almacenes con params {}", params); if (params == null) { params = new HashMap<>(); } if (!params.containsKey("max")) { params.put("max", 10); } else { params.put("max", Math.min((Integer) params.get("max"), 100)); } if (params.containsKey("pagina")) { Long pagina = (Long) params.get("pagina"); Long offset = (pagina - 1) * (Integer) params.get("max"); params.put("offset", offset.intValue()); } if (!params.containsKey("offset")) { params.put("offset", 0); } Criteria criteria = currentSession().createCriteria(Almacen.class); Criteria countCriteria = currentSession().createCriteria(Almacen.class); if (params.containsKey("empresa")) { criteria.createCriteria("empresa").add(Restrictions.idEq(params.get("empresa"))); countCriteria.createCriteria("empresa").add(Restrictions.idEq(params.get("empresa"))); } if (params.containsKey("filtro")) { String filtro = (String) params.get("filtro"); Disjunction propiedades = Restrictions.disjunction(); propiedades.add(Restrictions.ilike("nombre", filtro, MatchMode.ANYWHERE)); propiedades.add(Restrictions.ilike("nombreCompleto", filtro, MatchMode.ANYWHERE)); criteria.add(propiedades); countCriteria.add(propiedades); } if (params.containsKey("order")) { String campo = (String) params.get("order"); if (params.get("sort").equals("desc")) { criteria.addOrder(Order.desc(campo)); } else { criteria.addOrder(Order.asc(campo)); } } if (!params.containsKey("reporte")) { criteria.setFirstResult((Integer) params.get("offset")); criteria.setMaxResults((Integer) params.get("max")); } params.put("almacenes", criteria.list()); countCriteria.setProjection(Projections.rowCount()); params.put("cantidad", (Long) countCriteria.list().get(0)); return params; }
public static Criterion sameEnterpriseOrNull(final Enterprise enterprise) { Disjunction filterDisjunction = Restrictions.disjunction(); filterDisjunction.add(Restrictions.eq(Role.ENTERPRISE_PROPERTY, enterprise)); filterDisjunction.add(Restrictions.isNull(Role.ENTERPRISE_PROPERTY)); return filterDisjunction; }
public boolean exist(Usuario usuario) { Criteria criteria = this.getSession().createCriteria(Usuario.class); Disjunction ou = Restrictions.disjunction(); ou.add(Restrictions.eq("numeroDaCasa", usuario.getNumeroDaCasa())); ou.add(Restrictions.ilike("email", usuario.getEmail(), MatchMode.ANYWHERE)); return criteria.add(ou).list().size() > 0; }
@Override public void buildUnordered(Criteria criteria) { // Type check if (showEventTypesM.getObject().size() < numberOfEventTypes) criteria.add(Restrictions.in("type", showEventTypesM.getObject())); else log.debug("Not filtering by event type"); criteria.createAlias("user", "user"); // Site Check List<Site> siteList = showSitesM.getObject(); if (siteList.size() < numberOfSites || inAPeriod.getObject()) { criteria.createAlias("user.periods", "period", JoinType.LEFT_OUTER_JOIN); Disjunction siteRestriction = Restrictions.disjunction(); if (!inAPeriod.getObject()) siteRestriction.add(Restrictions.isEmpty("user.periods")); // Show users with no periods if (!siteList.isEmpty()) siteRestriction.add( Restrictions.in("period.site", siteList)); // Show users with matching periods if (inAPeriod.getObject() && siteList.isEmpty()) { siteRestriction.add(Restrictions.idEq(-1L)); // Halt query early; don't show anyone. criteria.setMaxResults(0); } criteria.add(siteRestriction); } else { log.debug("Not filtering by period/site"); } if (fromDateM.getObject() != null && toDateM.getObject() != null) { Date startDate = midnightStart(fromDateM.getObject()); Date endDate = midnightEnd(toDateM.getObject()); log.debug("Considering events between {} and {}", startDate, endDate); criteria.add(Restrictions.between("insertTime", startDate, endDate)); } // set permission check if (showPermissionUsers.getObject()) { criteria.add(Restrictions.eq("user.permission", true)); } // Also load ResponseData elements in the same query, to avoid thousands of subsequent // queries. criteria.setFetchMode("responseData", FetchMode.JOIN); // The join with periods results in multiple rows for multi-period users. // Unfortunately, this confuses the dataprovider, which still counts the duplicates // and therefore doesn't return a full page full of items each time. criteria.setResultTransformer( CriteriaSpecification .DISTINCT_ROOT_ENTITY); // Remove duplicate rows as a result of the INNER JOIN }
@SuppressWarnings("unchecked") public List<T> findByText(String searchText, String sortProp, boolean ascending) { List<Column> cols = HibernateUtil.getColumns(persistentClass.getName(), excludeDefault); Iterator<Column> it = cols.iterator(); Criteria crit = getSession().createCriteria(persistentClass); Disjunction disjunction = Restrictions.disjunction(); while (it.hasNext()) { Column col = it.next(); String colName = col.getName(); String propName = HibernateUtil.convertToHibernatePropertyName(colName); String type = HibernateUtil.getPropertyType(persistentClass, propName); if (type != null) { if (type.equals("integer") || type.equals("smallint")) { try { Integer.valueOf(searchText); Criterion criterium = Restrictions.eq(propName, Integer.valueOf(searchText)); disjunction.add(criterium); } catch (NumberFormatException ex) { } } else if (type.equals("string")) { Criterion criterium = Restrictions.ilike(propName, searchText, MatchMode.ANYWHERE); disjunction.add(criterium); } /*else if(type.equals("timestamp")){ Disjunction dis = Restrictions.disjunction(); SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd"); try { dis.add(Restrictions.eq(propName, format.parse(searchText))); } catch (ParseException e) { } try{ Integer.valueOf(searchText); dis.add(Restrictions.sqlRestriction( "YEAR(DATE("+colName+"))="+searchText+ " OR " + "MONTH(DATE("+colName+"))="+searchText+ " OR " + "DAY(DATE("+colName+"))="+searchText)); } catch(NumberFormatException ex) { } disjunction.add(dis); }*/ } } crit.add(disjunction); if (sortProp != null && !sortProp.equals("")) { if (ascending) crit.addOrder(Order.asc(sortProp)); else crit.addOrder(Order.desc(sortProp)); } return crit.list(); }
private void addLocationRestriction(Criteria criteria, Location medicalRecordLocation) { // in our current workflow, both paper records should always have the same record location, but, // just in case, // we fetch any merge reqeusts where *either* of the records are associated with the specified // record location criteria.createAlias("preferredPaperRecord", "ppr"); criteria.createAlias("notPreferredPaperRecord", "nppr"); Disjunction locationDisjunction = Restrictions.disjunction(); locationDisjunction.add(Restrictions.eq("ppr.recordLocation", medicalRecordLocation)); locationDisjunction.add(Restrictions.eq("nppr.recordLocation", medicalRecordLocation)); criteria.add(locationDisjunction); }
public List<Clients> getFromProxy(List<Clients> proxy) { Disjunction or = Restrictions.disjunction(); for (Clients pr : proxy) { or.add(Restrictions.eq("id", pr.getId())); } return sessionFactory.getCurrentSession().createCriteria(Clients.class).add(or).list(); }
private Criterion filterExactlyBy(final String filter) { Disjunction filterDisjunction = Restrictions.disjunction(); filterDisjunction.add(Restrictions.like(Role.NAME_PROPERTY, filter)); return filterDisjunction; }
/* * (non-Javadoc) * * @see com.pfchoice.core.dao.ICDMeasureDao#getPage(int, int, * java.lang.String, java.lang.String, java.lang.String) */ @Override public Pagination getPage( final int pageNo, final int pageSize, final String sSearch, final String sort, final String sortdir) { Criteria crit = createCriteria(); if (sSearch != null && !"".equals(sSearch)) { Disjunction or = Restrictions.disjunction(); or.add(Restrictions.ilike("code", "%" + sSearch + "%")) .add(Restrictions.ilike("description", "%" + sSearch + "%")) .add(Restrictions.ilike("hcc", "%" + sSearch + "%")) .add(Restrictions.ilike("rxhcc", "%" + sSearch + "%")); crit.add(or); } if (sort != null && !"".equals(sort)) { if (sortdir != null && !"".equals(sortdir) && "desc".equals(sortdir)) { crit.addOrder(Order.desc(sort)); } else { crit.addOrder(Order.asc(sort)); } } crit.add(Restrictions.eq("activeInd", 'Y')); return findByCriteria(crit, pageNo, pageSize); }
public static List<Object> getListObjectsByOrs( Class myClass, String strFieldName, List listArgs, String strDbName) { Session session = null; Transaction tx = null; List result = null; if (listArgs != null && listArgs.size() > 0) { try { session = getSessionDude(strDbName); // sessionFactory.getCurrentSession(); tx = session.beginTransaction(); Criteria criteria = session.createCriteria(myClass); Disjunction disj; Property property = Property.forName(strFieldName); if (listArgs != null && listArgs.size() > 0) { disj = Restrictions.disjunction(); for (Object strArgs : listArgs) { disj.add(property.eq(strArgs)); } tx.commit(); result = criteria.add(disj).list(); } } finally { if (session != null && session.isOpen()) { session.close(); } } } return result; }
public static Criterion in(String propertyName, Collection<?> values, int maxLength) { if (maxLength < 1) throw new IllegalArgumentException("maxLength must be positive"); Disjunction result = Restrictions.disjunction(); for (Collection<?> part : partitionCollection(values, maxLength)) { result.add(Restrictions.in(propertyName, part)); } return result; }
@Override public List<Daily> getFromProxy(List<Daily> proxy) { Disjunction or = Restrictions.disjunction(); for (Daily pr : proxy) { or.add(Restrictions.eq("id", pr.getId())); } return sessionFactory.getCurrentSession().createCriteria(Daily.class).add(or).list(); }
public Usuario procuraPor(String value) { Criteria criteria = this.getSession().createCriteria(Usuario.class); Disjunction ou = Restrictions.disjunction(); try { ou.add(Restrictions.eq("id", Integer.parseInt(value))); ou.add(Restrictions.eq("numeroDaCasa", Integer.parseInt(value))); } catch (NumberFormatException nfe) { } try { ou.add(Restrictions.eq("tipoDeUsuario", TipoDeUsuario.valueOf(value.toUpperCase()))); } catch (IllegalArgumentException ce) { } ou.add(Restrictions.ilike("email", value, MatchMode.ANYWHERE)); ou.add(Restrictions.ilike("login", value, MatchMode.ANYWHERE)); return (Usuario) criteria.add(ou).uniqueResult(); }
public static void ganThuocTinhTimKiem( Criteria crit, TaiKhoan tk, String strDaXoa, String strDaBan) { if (tk.getMaTaiKhoan() != "") { Disjunction or = Restrictions.disjunction(); or.add(Restrictions.ilike("maTaiKhoan", "%" + tk.getMaTaiKhoan() + "%")); or.add(Restrictions.ilike("maTaiKhoan", tk.getMaTaiKhoan() + "%")); or.add(Restrictions.ilike("maTaiKhoan", "%" + tk.getMaTaiKhoan())); or.add(Restrictions.ilike("maTaiKhoan", tk.getMaTaiKhoan())); crit.add(or); } if (tk.getLoaiTaiKhoan() != null) { crit.add(Restrictions.eq("loaiTaiKhoan", tk.getLoaiTaiKhoan())); } if (strDaXoa != "") { crit.add(Restrictions.eq("daXoa", tk.getDaXoa())); } if (strDaBan != "") { crit.add(Restrictions.eq("daBan", tk.getDaBan())); } }
private static void setAuthorizedSiteData(DetachedCriteria criteria, List<SiteData> sites) { Disjunction disjunction = Restrictions.disjunction(); for (SiteData sd : sites) { Conjunction con = new Conjunction(); con.add(Restrictions.eq("dpSiteName", sd.getSiteName())); con.add(Restrictions.eq("project", sd.getCollection())); disjunction.add(con); } criteria.add(disjunction); }
public List<DmDocument> getNotStoredDocList(int numDocs) { Disjunction disjunction = Restrictions.disjunction(); disjunction.add(Restrictions.isNull("termFreqStored.id")); disjunction.add(Restrictions.neProperty("timeIndexed", "termFreqStored.timeIndexed")); Criteria crit = getSession().createCriteria(DmDocumentIndexed.class); crit.setProjection(Projections.property("document")); crit.createAlias("document", "doc", CriteriaSpecification.LEFT_JOIN); crit.createAlias( "doc.docTermFreqStoredList", "termFreqStored", CriteriaSpecification.LEFT_JOIN); crit.add(Restrictions.eq("isNeedReindex", false)); crit.add(disjunction); crit.addOrder(Order.asc("timeIndexed")); crit.setMaxResults(numDocs); List<DmDocument> documentList = crit.list(); // start - trigger lazy fetch for (DmDocument documentTmp : documentList) { if (documentTmp.getDocTermFreqStoredList() != null) { documentTmp.getDocTermFreqStoredList().size(); } if (documentTmp.getDocumentIndexedList() != null) { documentTmp.getDocumentIndexedList().size(); } // if (documentTmp.getDocumentAuthorList() != null) { // documentTmp.getDocumentAuthorList().size(); // } // if (documentTmp.getDocumentKeywordList() != null) { // documentTmp.getDocumentKeywordList().size(); // } if (documentTmp.getDocumentFolderList() != null) { documentTmp.getDocumentFolderList().size(); // for (DmDocumentFolder docFolder : documentTmp.getDocumentFolderList()) { // docFolder.getFolder().getPermissionList().size(); // } } } // end - trigger lazy fetch return documentList; }
/** * Perform a search over all child and sub orgs within the given organisation * * <p>If a search query is given it will be split by space and the key words searched in the * title, orgid, address, addressLine2 and postcode fields. * * @param q - search query, which is a space seperated list of key words. Optional * @param organisation - search is for orgs inside this * @param orgType - optional, if given results are limited to organisations of this type * @param session * @return */ public static List<Organisation> search( String q, Organisation organisation, OrgType orgType, Session session) { Criteria crit = session.createCriteria(Organisation.class); crit.setCacheable(true); Disjunction notDeleted = Restrictions.disjunction(); notDeleted.add(Restrictions.isNull("deleted")); notDeleted.add(Restrictions.eq("deleted", Boolean.FALSE)); crit.add(notDeleted); if (q != null) { String[] arr = q.split(" "); Conjunction con = Restrictions.conjunction(); for (String queryPart : arr) { Disjunction dis = Restrictions.disjunction(); String s = "%" + queryPart + "%"; dis.add(Restrictions.ilike("title", s)); dis.add(Restrictions.ilike("orgId", s)); dis.add(Restrictions.ilike("address", s)); dis.add(Restrictions.ilike("addressLine2", s)); dis.add(Restrictions.ilike("postcode", s)); con.add(dis); } crit.add(con); } if (orgType != null) { crit.add(Restrictions.eq("orgType", orgType)); } // TODO: add other properties like address Criteria critParentLink = crit.createCriteria("parentOrgLinks"); critParentLink.add(Restrictions.eq("owner", organisation)); crit.addOrder(Order.asc("title")); return DbUtils.toList(crit, Organisation.class); }
@Override public void botaoBuscarActionPerformed(ActionEvent evt) { try { String busca = getCampoBusca().getText(); Disjunction or = Restrictions.disjunction(); or.add(Restrictions.ilike("nome", busca, MatchMode.ANYWHERE)); // or.add(Restrictions.ilike("ativo", busca, MatchMode.ANYWHERE)); try { or.add(Restrictions.eq("id", Integer.parseInt(busca))); } catch (Exception err) { } List<Object> grupos = ProfissionalDAO.getInstance() .findByCriteria(new Profissional(), Restrictions.conjunction(), or); this.atualizarGrid(-1, grupos); } catch (Exception err) { SOptionPane.showMessageDialog(this, err, "Erro!", JOptionPane.ERROR_MESSAGE); } }
public static long countChildOrgs(Organisation organisation, Session session) { Criteria crit = session.createCriteria(Organisation.class); crit.setCacheable(true); Disjunction notDeleted = Restrictions.disjunction(); notDeleted.add(Restrictions.isNull("deleted")); notDeleted.add(Restrictions.eq("deleted", Boolean.FALSE)); crit.add(notDeleted); crit.add(Restrictions.ne("id", organisation.getId())); Criteria critParentLink = crit.createCriteria("parentOrgLinks"); critParentLink.add(Restrictions.eq("owner", organisation)); crit.setProjection(Projections.count("id")); Object result = crit.uniqueResult(); if (result == null) { return 0; } else if (result instanceof Integer) { Integer i = (Integer) result; return i.longValue(); } else { return (long) result; } }
private <T extends ResourceManagementHB> void createRasdManagement( Session session, int[] resourceTypes, Class<T> cl) throws PersistenceException { VirtualappHB virtualAppHB = (VirtualappHB) session.get("VirtualappExtendedHB", vApp.getIdVirtualApp()); VirtualDataCenterHB virtualDataCenterHB = virtualAppHB.getVirtualDataCenterHB(); Disjunction virtualAppDisjuction = Restrictions.disjunction(); virtualAppDisjuction.add(Restrictions.eq("idVirtualApp", virtualAppHB.getIdVirtualApp())); ArrayList<NodeHB> nodes = (ArrayList<NodeHB>) session.createCriteria(NodeHB.class).add(virtualAppDisjuction).list(); VirtualmachineHB virtualMachineHB; ArrayList<ResourceAllocationSettingData> rasds; ResourceManagementHB resourceManagement = null; Timestamp timestamp = new Timestamp(new GregorianCalendar().getTimeInMillis()); for (NodeHB node : nodes) { if (node.getType() == NodeTypeEnum.VIRTUAL_IMAGE) { NodeVirtualImageHB nodeVirtualImage = (NodeVirtualImageHB) node; virtualMachineHB = nodeVirtualImage.getVirtualMachineHB(); if (virtualMachineHB != null) { for (int resourceType : resourceTypes) { rasds = getRasds(session, resourceType); for (ResourceAllocationSettingData rasd : rasds) { try { resourceManagement = cl.newInstance(); } catch (Exception e) { throw new PersistenceException( "Unable to create a new instance of " + cl.getName()); } resourceManagement.setIdResourceType(rasd.getResourceType() + ""); resourceManagement.setRasd(rasd); resourceManagement.setVirtualApp(virtualAppHB); resourceManagement.setVirtualMachine(virtualMachineHB); resourceManagement.setVirtualDataCenter(virtualDataCenterHB); session.saveOrUpdate(resourceManagement); resourceManagementHBs.add(resourceManagement); } } } } } }
public static List getListObjectsByAnds_Ors( Class myClass, Map<String, Object> mapArgsAnds, String strFieldName, List listArgsOrs, String strDbName) { List resutl = null; Session session = null; Transaction tx = null; try { session = getSessionDude(strDbName); // sessionFactory.getCurrentSession(); tx = session.beginTransaction(); Criteria criteria = session.createCriteria(myClass); if (mapArgsAnds != null && mapArgsAnds.size() > 0) { Iterator iter = mapArgsAnds.entrySet().iterator(); while (iter.hasNext()) { Map.Entry<String, Object> pair = (Map.Entry<String, Object>) iter.next(); criteria.add(Restrictions.eq(pair.getKey(), pair.getValue())); } } if (listArgsOrs != null && listArgsOrs.size() > 0) { Disjunction disj; Property property = Property.forName(strFieldName); if (listArgsOrs != null && listArgsOrs.size() > 0) { disj = Restrictions.disjunction(); for (Object strArgs : listArgsOrs) { disj.add(property.eq(strArgs)); } resutl = criteria.add(disj).list(); } tx.commit(); if (resutl == null) { resutl = criteria.list(); } } } finally { if (session != null && session.isOpen()) { session.close(); } } return resutl; }
public Map<String, Object> lista(Map<String, Object> params) { log.debug("Buscando lista de Temporada Colportor con params {}", params); if (params == null) { params = new HashMap<>(); } if (!params.containsKey(Constantes.CONTAINSKEY_MAX)) { params.put(Constantes.CONTAINSKEY_MAX, 10); } else { params.put( Constantes.CONTAINSKEY_MAX, Math.min((Integer) params.get(Constantes.CONTAINSKEY_MAX), 100)); } if (params.containsKey(Constantes.CONTAINSKEY_PAGINA)) { Long pagina = (Long) params.get(Constantes.CONTAINSKEY_PAGINA); Long offset = (pagina - 1) * (Integer) params.get(Constantes.CONTAINSKEY_MAX); params.put(Constantes.CONTAINSKEY_OFFSET, offset.intValue()); } if (!params.containsKey(Constantes.CONTAINSKEY_OFFSET)) { params.put(Constantes.CONTAINSKEY_OFFSET, 0); } Criteria criteria = currentSession().createCriteria(TemporadaColportor.class); Criteria countCriteria = currentSession().createCriteria(TemporadaColportor.class); if (params.containsKey(Constantes.CONTAINSKEY_FILTRO)) { String filtro = (String) params.get(Constantes.CONTAINSKEY_FILTRO); filtro = "%" + filtro + "%"; Disjunction propiedades = Restrictions.disjunction(); propiedades.add(Restrictions.ilike("status", filtro)); criteria.add(propiedades); countCriteria.add(propiedades); } if (params.containsKey(Constantes.CONTAINSKEY_ORDER)) { String campo = (String) params.get(Constantes.CONTAINSKEY_ORDER); if (params.get(Constantes.CONTAINSKEY_SORT).equals(Constantes.CONTAINSKEY_SORT)) { criteria.addOrder(Order.desc(campo)); } else { criteria.addOrder(Order.asc(campo)); } } if (!params.containsKey(Constantes.CONTAINSKEY_REPORTE)) { criteria.setFirstResult((Integer) params.get(Constantes.CONTAINSKEY_OFFSET)); criteria.setMaxResults((Integer) params.get(Constantes.CONTAINSKEY_MAX)); } params.put(Constantes.CONTAINSKEY_TEMPORADACOLPORTORES, criteria.list()); countCriteria.setProjection(Projections.rowCount()); params.put(Constantes.CONTAINSKEY_CANTIDAD, (Long) countCriteria.list().get(0)); return params; }
@Override public int obtenhaQuantidadePorUF(UF estado) { Criteria c = getSession().createCriteria(Cliente.class); c.createAlias("enderecoPrimario", "endp"); c.createAlias("enderecoSecundario", "ends"); Disjunction d = Restrictions.disjunction(); d.add(Restrictions.eq("endp.uf", estado.getSigla())); d.add(Restrictions.eq("ends.uf", estado.getSigla())); c.setProjection(Projections.count("codigo")); c.add(d); return (int) c.uniqueResult(); }
private void addStatusDisjunctionRestriction( Criteria criteria, List<PaperRecordMergeRequest.Status> statusList) { if (statusList.size() == 1) { criteria.add(Restrictions.eq("status", statusList.get(0))); } else { Disjunction statusDisjunction = Restrictions.disjunction(); for (PaperRecordMergeRequest.Status status : statusList) { statusDisjunction.add(Restrictions.eq("status", status)); } criteria.add(statusDisjunction); } }
/** * Gets a lists of ResourceAllocationSettingData that correspond to a particular resource type * * @param session * @param resourceType * @return */ private static ArrayList<ResourceAllocationSettingData> getRasds( Session session, int resourceType) { Disjunction disjunction = Restrictions.disjunction(); disjunction.add(Restrictions.eq("resourceType", resourceType)); ArrayList<ResourceAllocationSettingData> rasds = (ArrayList<ResourceAllocationSettingData>) session.createCriteria(ResourceAllocationSettingData.class).add(disjunction).list(); if (rasds == null) { rasds = new ArrayList<ResourceAllocationSettingData>(); } return rasds; }
/** * 解析一个条件成为符合Hibernate的Junction的实例条件 * * @param condition * @param junction */ public static void parseConditionToJunction( Condition condition, Junction junction, Class<?> persistentClass) { // 子条件 List<Condition> subConditions = condition.getSubConditions(); // 有子条件则进行遍历获取最终的条件 if (null != subConditions && !subConditions.isEmpty()) { // 子条件当中的and条件集合 List<Condition> andConditions = condition.getAndConditions(); if (null != andConditions && !andConditions.isEmpty()) { // 创建一个and条件集合 Conjunction conj = Restrictions.conjunction(); // 添加到父条件中 junction.add(conj); for (Condition andCondition : andConditions) { /* * 把每个条件看做是一个大的条件(包含 and 和 or 2个部分), * 然后使用disjunction连接条件集合来组合这个大条件的(and项 和 or项); * 因为and项和or项都已经被分为2个部分 * ,而且又是用disjunction来组合,所以可以保证一个大条件只会被or连接符分隔成2个部分 */ Disjunction dj = Restrictions.disjunction(); conj.add(dj); parseConditionToJunction(andCondition, dj, persistentClass); } } // 子条件当中的or条件集合 List<Condition> orConditions = condition.getOrConditions(); if (null != orConditions && !orConditions.isEmpty()) { // 创建一个or条件集合 Disjunction disj = Restrictions.disjunction(); // 添加到父条件中 junction.add(disj); for (Condition orCondition : orConditions) { // 这里的实现原理与上面的andCondition的处理相同 Disjunction dj = Restrictions.disjunction(); disj.add(dj); parseConditionToJunction(orCondition, dj, persistentClass); } } } else { // 条件为最终条件,转换为符合Hibernate的条件,然后条件到条件集合中 junction.add(condition.getCriterion(persistentClass)); } }
public void appendDiscriminators(Criteria criteria) { // Add the special discriminator value constraint if (!discriminators.isEmpty()) { // Translate the discriminators into classes final List<Class<?>> classes = getClassesByDiscriminators(discriminators); if (classes.size() == 1) { criteria.add(Restrictions.eq("class", classes.get(0))); } else { final Disjunction or = Restrictions.disjunction(); for (Class<?> clazz : classes) or.add(Restrictions.eq("class", clazz)); criteria.add(or); } } }