/** * If the measurement baselines for the corresponding resources are the same, that value will be * returned; otherwise null will be returned */ public MeasurementBaseline getBaselineIfEqual(Subject subject, int groupId, int definitionId) { Query query = entityManager.createQuery( "" // + "SELECT MIN(mb.baselineMin), MAX(mb.baselineMin), " // + " MIN(mb.baselineMean), MAX(mb.baselineMean), " // + " MIN(mb.baselineMax), MAX(mb.baselineMax), " // + " COUNT(mb.id) " // + " FROM MeasurementBaseline mb " // + " JOIN mb.schedule ms " // + " JOIN ms.resource res " // + " JOIN res.implicitGroups rg " // + " WHERE rg.id = :groupId " // + " AND ms.definition.id = :definitionId "); query.setParameter("groupId", groupId); query.setParameter("definitionId", definitionId); Object[] results = (Object[]) query.getSingleResult(); MeasurementBaseline baseline = new MeasurementBaseline(); if ((Long) results[6] == 0) { // no baselines calculated yet, return null to indicate that return null; } // there was at least one baseline, so one or more of min/mean/max might be non-null if (results[0] == null || results[1] == null) { baseline.setMin(null); } else if (Math.abs((Double) results[0] - (Double) results[1]) < 1e-9) { baseline.setMin((Double) results[0]); // they are close enough to being equal } else { baseline.setMin( -1.0); // use negative to represent mixed, because we currently don't support graphing // negs } if (results[2] == null || results[3] == null) { baseline.setMean(null); } else if (Math.abs((Double) results[2] - (Double) results[3]) < 1e-9) { baseline.setMean((Double) results[2]); // they are close enough to being equal } else { baseline.setMean( -1.0); // use negative to represent mixed, because we currently don't support graphing // negs } if (results[4] == null || results[5] == null) { baseline.setMax(null); } else if (Math.abs((Double) results[4] - (Double) results[5]) < 1e-9) { baseline.setMax((Double) results[4]); // they are close enough to being equal } else { baseline.setMax( -1.0); // use negative to represent mixed, because we currently don't support graphing // negs } return baseline; }
private MeasurementBaseline calculateBaselineForGroup( int groupId, int definitionId, boolean userEntered, long startDate, long endDate, boolean save) throws DataNotAvailableException, BaselineCreationException { MeasurementAggregate agg = dataManager.getAggregate( subjectManager.getOverlord(), groupId, definitionId, startDate, endDate); Subject overlord = subjectManager.getOverlord(); List<Integer> resourceIds = resourceManager.findImplicitResourceIdsByResourceGroup(groupId); List<MeasurementSchedule> schedules = measurementScheduleManager.findSchedulesByResourceIdsAndDefinitionId( overlord, ArrayUtils.unwrapCollection(resourceIds), definitionId); MeasurementBaseline baseline = null; for (MeasurementSchedule schedule : schedules) { // attach the entity, so we can find the baseline schedule = entityManager.merge(schedule); if (save && (schedule.getBaseline() != null)) { /* * If saving, make sure we're updating the existing one, if it exists */ baseline = schedule.getBaseline(); } else { /* * Otherwise, if we're not saving or if the the schedule doesn't have a current baseline, we create a new * baseline object */ baseline = new MeasurementBaseline(); if (save) { /* * But, if we *are* in save mode, then set the relationship so when we merge the schedule below it * persists this new baseline too */ baseline.setSchedule(schedule); } } baseline.setUserEntered(userEntered); baseline.setMean(agg.getAvg()); baseline.setMin(agg.getMin()); baseline.setMax(agg.getMax()); if (save) { entityManager.persist(baseline); entityManager.merge(schedule); } } // all baselines should be the same return baseline; }
private MeasurementBaseline calculateBaseline( MeasurementSchedule schedule, boolean userEntered, long startDate, long endDate, boolean save) throws DataNotAvailableException, BaselineCreationException { /* * jmarques: 2007-10-26 * * navigation from schedule to definition is safe here because the only caller to this method is * calculateAutoBaseline( Subject, Integer, long, long, boolean ), which uses entityManager.find, so the * schedule should still be attached since the transaction is propagated to this method */ if (schedule.getDefinition().getNumericType() != NumericType.DYNAMIC) { throw new BaselineCreationException( "Baseline calculation is only valid for a dynamic measurement"); } MeasurementAggregate agg = dataManager.getAggregate( subjectManager.getOverlord(), schedule.getId(), startDate, endDate); // attach the entity, so we can find the baseline schedule = entityManager.merge(schedule); MeasurementBaseline baseline = null; if (save && (schedule.getBaseline() != null)) { /* * If saving, make sure we're updating the existing one, if it exists */ baseline = schedule.getBaseline(); } else { /* * Otherwise, if we're not saving or if the the schedule doesn't have a current baseline, we create a new * baseline object */ baseline = new MeasurementBaseline(); if (save) { /* * But, if we *are* in save mode, then set the relationship so when we merge the schedule below it * persists this new baseline too */ baseline.setSchedule(schedule); } } baseline.setUserEntered(userEntered); baseline.setMean(agg.getAvg()); baseline.setMin(agg.getMin()); baseline.setMax(agg.getMax()); if (save) { entityManager.persist(baseline); entityManager.merge(schedule); } return baseline; }