private int getNumServices(int nodeId, List<String> serviceNames) { final CriteriaBuilder builder = new CriteriaBuilder(OnmsMonitoredService.class) .alias("ipInterface", "ipInterface") .alias("ipInterface.node", "node") .eq("ipInterface.isManaged", "M") .eq("node.id", nodeId); if (serviceNames != null && serviceNames.size() > 0) { builder.alias("serviceType", "serviceType") .in("serviceType.name", serviceNames); } // Retrieve the services and group them by node id return m_monitoredServiceDao.countMatching(builder.toCriteria()); }
public OnmsAlarm getAlarm(int nodeId) { CriteriaBuilder builder = new CriteriaBuilder(OnmsAlarm.class); builder.alias("node", "node"); builder.ne("severity", OnmsSeverity.CLEARED); builder.orderBy("severity").desc(); builder.eq("node.id", nodeId); builder.limit(Integer.valueOf(1)); List<OnmsAlarm> alarms = alarmDao.findMatching(builder.toCriteria()); return alarms == null || alarms.isEmpty() ? null : alarms.get(0); } }
public void addRestriction(String property, CriteriaBuilderHelper criteriaBuilderHelper, CriteriaBuilder criteriaBuilder, Object[] values) { criteriaBuilder.ilike(values[0].toString(), values[1]); } },
@Override @Transactional public Optional<OnmsAcknowledgment> findLatestAckForRefId(Integer refId) { CriteriaBuilder builder = new CriteriaBuilder(OnmsAcknowledgment.class) .eq("refId", refId) .limit(1) .orderBy("ackTime").desc() .orderBy("id").desc(); List<OnmsAcknowledgment> acks = findMatching(builder.toCriteria()); return acks.size() == 1 ? Optional.of(acks.get(0)) : Optional.empty(); } }
@Override public List<SearchResult> query(SearchQuery searchQuery, GraphContainer container) { LOG.info("ApplicationServiceSearchProvider->query: called with search query: '{}'", searchQuery); List<SearchResult> results = Lists.newArrayList(); String queryString = searchQuery.getQueryString(); CriteriaBuilder bldr = new CriteriaBuilder(OnmsApplication.class); if (queryString != null && queryString.length() > 0) { bldr.ilike("name", String.format("%%%s%%", queryString)); } bldr.orderBy("name", true); bldr.limit(10); Criteria dbQueryCriteria = bldr.toCriteria(); for (OnmsApplication application : applicationDao.findMatching(dbQueryCriteria)) { final ApplicationVertex applicationVertex = new ApplicationVertex(application); SearchResult searchResult = new SearchResult(applicationVertex, true, false); results.add(searchResult); } LOG.info("ApplicationServiceSearchProvider->query: found {} results: {}", results.size(), results); return results; }
@Override @Transactional public List<OnmsAcknowledgment> getAcknowledgments(int alarmId) { CriteriaBuilder cb = new CriteriaBuilder(OnmsAcknowledgment.class); cb.eq("refId", alarmId); cb.eq("ackType", AckType.ALARM); return m_ackDao.findMatching(cb.toCriteria()); }
/** * Searches for alarms with the given criterias and returns the number found. * * @param acknowledged search for acknowledged or unacknowledged alarms * @param age the age of the alarms * @param uei search for alarms with the specified uei * @return number of alarms found */ public int countByUei(boolean acknowledged, long age, String uei) { CriteriaBuilder criteriaBuilder = new CriteriaBuilder(OnmsAlarm.class); if (acknowledged) { criteriaBuilder.isNotNull("alarmAckUser"); } else { criteriaBuilder.isNull("alarmAckUser"); } criteriaBuilder.eq("uei", uei); criteriaBuilder.sql("EXTRACT(EPOCH FROM CURRENT_TIMESTAMP - lastEventTime) < ?", age, Type.LONG); return m_alarmDao.countMatching(criteriaBuilder.toCriteria()); }
private List<OnmsNode> getNodes(List<Integer> ids) { if (ids == null || ids.isEmpty()) { return new ArrayList<>(); } final List<OnmsNode> nodes = nodeDao.findMatching(new CriteriaBuilder(OnmsNode.class).in("id", ids).toCriteria()); return nodes; }
private List<OnmsAlarm> findAlarms(final List<SearchResult> results, final String queryString) { CriteriaBuilder bldr = new CriteriaBuilder(OnmsAlarm.class); OnmsSeverity severity = OnmsSeverity.get(queryString); List<OnmsAlarm> alarms; if (!OnmsSeverity.INDETERMINATE.equals(severity)) { bldr = new CriteriaBuilder(OnmsAlarm.class); bldr.eq("severity", severity); alarms = alarmProvider.findMatchingAlarms(bldr.toCriteria()); if (alarms.size() > 0) { AlarmSearchResult result = new AlarmSearchResult(queryString); result.setSeverityQuery(true); results.add(result); } } else { bldr.isNotNull("node").ilike("uei", "%"+queryString+"%").orderBy("node"); alarms = alarmProvider.findMatchingAlarms(bldr.toCriteria()); } return alarms; }
@Override public List<OnmsAlarm> doInTransaction(TransactionStatus transactionStatus) { final CriteriaBuilder criteriaBuilder = new CriteriaBuilder(OnmsAlarm.class); criteriaBuilder.alias("node", "node"); criteriaBuilder.ne("node.type", "D"); criteriaBuilder.limit(100); criteriaBuilder.distinct(); List<String> parameters = new ArrayList<>(rowCategories.stream().map(OnmsCategory::getName).collect(Collectors.toList())); parameters.addAll(colCategories.stream().map(OnmsCategory::getName).collect(Collectors.toList())); Type[] types = new Type[parameters.size()]; Arrays.fill(types, Type.STRING); // Restrict on OnmsAlarm.nodeId criteriaBuilder.sql( createQuery("{alias}.nodeId", rowCategories, colCategories), parameters.toArray(new String[parameters.size()]), types ); return m_alarmDao.findMatching(criteriaBuilder.toCriteria()); } });
CriteriaBuilder criteriaBuilder = new CriteriaBuilder(OnmsNotification.class); criteriaBuilder.alias("node", "node"); criteriaBuilder.sql( createQuery("{alias}.nodeId", rowCategories, colCategories), parameters.toArray(new String[parameters.size()]), ); criteriaBuilder.ne("node.type", "D"); criteriaBuilder.orderBy("pageTime", false); Criteria myCriteria = criteriaBuilder.toCriteria();
criteriaBuilder.alias("group", "group"); final Set<Integer> groupFilter = UriInfoUtils.getValues(uriInfo, "groupFilter", Collections.emptyList()) .stream().map(g -> g != null ? g.trim() : g) .collect(Collectors.toSet()); if (!groupFilter.isEmpty()) { criteriaBuilder.in("group.id", groupFilter); if (rawQuery != null && !rawQuery.trim().isEmpty()) { final String query = "%" + rawQuery + "%"; criteriaBuilder.or( Restrictions.iplike("src_address", rawQuery), // use column for iplike and not the entity property Restrictions.like("srcAddress", query), Restrictions.ilike("name", query), Restrictions.ilike("exporterFilter", query), Restrictions.ilike("protocol", query)).toCriteria(); criteriaBuilder.clearOrder(); criteriaBuilder.orderBy("group.priority", false); criteriaBuilder.orderBy(order.getColumn(), queryParameters.getOrder().isAsc()); criteriaBuilder.eq("group.enabled", true); return createResponse(criteriaBuilder, (criteria) -> classificationService.findMatchingRules(criteria),
private Map<Integer, List<OnmsOutage>> getOutages(List<Integer> nodeIds, List<String> serviceNames, Date start, Date end) { if (nodeIds == null || nodeIds.size() == 0) { return Maps.newHashMap(); } final CriteriaBuilder builder = new CriteriaBuilder(OnmsOutage.class) // The outage must have started before the end of the window .le("ifLostService", end) .or(new NullRestriction("ifRegainedService"), // The outage is ongoing new AllRestriction( // or the outage was cleared somewhere in the window new GtRestriction("ifRegainedService", start), new LeRestriction("ifRegainedService", end)) ) // Only select outages affecting our nodes .alias("monitoredService", "monitoredService") .alias("monitoredService.ipInterface", "ipInterface") .alias("ipInterface.node", "node") .eq("ipInterface.isManaged", "M") .in("node.id", nodeIds); // Only select outages affecting services with the given names, if set if (serviceNames != null && serviceNames.size() > 0) { builder.alias("monitoredService.serviceType", "serviceType") .in("serviceType.name", serviceNames); } // Retrieve the outages and group them by node id return m_outageDao.findMatching(builder.toCriteria()).stream() .collect(Collectors.groupingBy(OnmsOutage::getNodeId)); }
private List<OnmsNode> getNodes(GeolocationQuery query) { CriteriaBuilder criteriaBuilder = new CriteriaBuilder(OnmsNode.class) .alias("assetRecord", "assetRecord") .and( Restrictions.isNotNull("assetRecord"), Restrictions.isNotNull("assetRecord.geolocation") ); if (query.getLocation() != null) { criteriaBuilder.and(Restrictions.eq("location", query.getLocation())); } if (!query.getNodeIds().isEmpty()) { criteriaBuilder.in("id", query.getNodeIds()); } return genericPersistenceAccessor.findMatching(criteriaBuilder.toCriteria()); }
@Override public Status getStatusForVertex(VertexRef vertexRef) { if(vertexRef.getNamespace().equals("nodes")) { if(isGroup(vertexRef) && getVertexProvider() != null) { return getStatusForGroup(vertexRef); } else { try { int nodeId = Integer.valueOf(vertexRef.getId()); CriteriaBuilder builder = new CriteriaBuilder(OnmsAlarm.class); builder.alias("node", "node"); builder.eq("node.id", nodeId); builder.ge("severity", OnmsSeverity.WARNING); builder.orderBy("severity").desc(); builder.limit(1); return getStatusForCriteria(builder); }catch(NumberFormatException e) { return createIndeterminateStatus(); } } } else { return createIndeterminateStatus(); } }
private Status getStatusForGroup(VertexRef groupRef) { List<Vertex> vertices = getVertexProvider().getChildren(groupRef); Collection<Integer> nodeIds = new ArrayList<Integer>(); for(Vertex vertex : vertices) { if(!vertex.isGroup()) { nodeIds.add(vertex.getNodeID()); } } CriteriaBuilder builder = new CriteriaBuilder(OnmsAlarm.class); builder.alias("node", "node"); builder.in("node.id", nodeIds); builder.ge("severity", OnmsSeverity.WARNING); builder.orderBy("severity").desc(); builder.limit(1); return getStatusForCriteria(builder); }
CriteriaBuilder bldr = new CriteriaBuilder(OnmsIpInterface.class); bldr.iplike("ipAddr", queryString).orderBy("ipAddress", true); Criteria dbQueryCriteria = bldr.toCriteria(); List<OnmsIpInterface> ips;
/** * Returns the alarms defined by this dashlet. * * @return the list of alarms */ private List<OnmsAlarm> getAlarms() { final CriteriaBuilder alarmCb = new CriteriaBuilder(OnmsAlarm.class); alarmCb.alias("node", "node"); alarmCb.alias("node.categories", "category"); alarmCb.alias("lastEvent", "event"); String criteria = getDashletSpec().getParameters().get("criteria"); m_criteriaBuilderHelper.parseConfiguration(alarmCb, criteria); alarmCb.fetch("firstEvent", Fetch.FetchType.EAGER); alarmCb.fetch("lastEvent", Fetch.FetchType.EAGER); /** * due to restrictions in the criteria api it's quite hard * to use distinct and orderBy together, so I apply a workaround * to avoid alarmCb.distinct(); */ List<OnmsAlarm> onmsAlarmList = m_alarmDao.findMatching(alarmCb.toCriteria()); Map<Integer, OnmsAlarm> onmsAlarmMap = new LinkedHashMap<>(); for (OnmsAlarm onmsAlarm : onmsAlarmList) { if (!onmsAlarmMap.containsKey(onmsAlarm.getId())) { onmsAlarmMap.put(onmsAlarm.getId(), onmsAlarm); } } return Lists.newArrayList(onmsAlarmMap.values()); }
/** * Retrieves all of the outages (using DAOs) associated with * the given service. */ private List<OnmsOutage> getOutages(MockService svc) { OnmsMonitoredService monitoredSvc = m_monitoredServiceDao.get( svc.getNodeId(), svc.getAddress(), svc.getSvcName()); Criteria criteria = new CriteriaBuilder(OnmsOutage.class) .eq("monitoredService", monitoredSvc) .orderBy("ifLostService") .toCriteria(); return m_outageDao.findMatching(criteria); }
@Override public Long getAlarmCount() { final CriteriaBuilder criteriaBuilder = new CriteriaBuilder(OnmsAlarm.class); return sessionUtils.withReadOnlyTransaction(() -> (long)alarmDao.countMatching(criteriaBuilder.toCriteria())); }