Examples with AggregatedGroupMapping org.apereo.portal.events.aggr.groups.AggregatedGroupMapping used on opensource projects

Example 16 with AggregatedGroupMapping

use of org.apereo.portal.events.aggr.groups.AggregatedGroupMapping in project uPortal by Jasig.

the class EventAggregationConfigurationImporterExporter method importData.

@Transactional("aggrEventsTransactionManager")
@Override
public void importData(ExternalEventAggregationConfiguration data) {
    //Import interval configs
    final Set<AggregatedIntervalConfig> oldAggregatedIntervalConfigs = new HashSet<AggregatedIntervalConfig>(this.aggregationManagementDao.getAggregatedIntervalConfigs());
    for (final ExternalAggregatedIntervalConfig extAggregatedIntervalConfig : data.getAggregatedIntervalConfigs()) {
        final String aggregatorTypeName = extAggregatedIntervalConfig.getAggregatorType();
        final Class<? extends IPortalEventAggregator> aggregatorType = getAggregatorType(aggregatorTypeName);
        AggregatedIntervalConfig aggregatedIntervalConfig = this.aggregationManagementDao.getAggregatedIntervalConfig(aggregatorType);
        if (aggregatedIntervalConfig == null) {
            aggregatedIntervalConfig = this.aggregationManagementDao.createAggregatedIntervalConfig(aggregatorType);
        }
        //Remove the config from the old configs set, marking it as updated
        oldAggregatedIntervalConfigs.remove(aggregatedIntervalConfig);
        //Copy over excludes
        final Set<AggregationInterval> excluded = aggregatedIntervalConfig.getExcluded();
        excluded.clear();
        for (final ExternalAggregationInterval extInterval : extAggregatedIntervalConfig.getExcludes()) {
            excluded.add(convert(extInterval));
        }
        //Copy over includes
        final Set<AggregationInterval> included = aggregatedIntervalConfig.getIncluded();
        included.clear();
        for (final ExternalAggregationInterval extInterval : extAggregatedIntervalConfig.getIncludes()) {
            included.add(convert(extInterval));
        }
        this.aggregationManagementDao.updateAggregatedIntervalConfig(aggregatedIntervalConfig);
    }
    //Delete interval configs that were not updated
    for (final AggregatedIntervalConfig aggregatedIntervalConfig : oldAggregatedIntervalConfigs) {
        this.aggregationManagementDao.deleteAggregatedIntervalConfig(aggregatedIntervalConfig);
    }
    //Import Group configs
    final Set<AggregatedGroupConfig> oldAggregatedGroupConfigs = new HashSet<AggregatedGroupConfig>(this.aggregationManagementDao.getAggregatedGroupConfigs());
    for (final ExternalAggregatedGroupConfig extAggregatedGroupConfig : data.getAggregatedGroupConfigs()) {
        final String aggregatorTypeName = extAggregatedGroupConfig.getAggregatorType();
        final Class<? extends IPortalEventAggregator> aggregatorType = getAggregatorType(aggregatorTypeName);
        AggregatedGroupConfig aggregatedGroupConfig = this.aggregationManagementDao.getAggregatedGroupConfig(aggregatorType);
        if (aggregatedGroupConfig == null) {
            aggregatedGroupConfig = this.aggregationManagementDao.createAggregatedGroupConfig(aggregatorType);
        }
        //Remove the config from the old configs set, marking it as updated
        oldAggregatedGroupConfigs.remove(aggregatedGroupConfig);
        //Copy over excludes
        final Set<AggregatedGroupMapping> excluded = aggregatedGroupConfig.getExcluded();
        excluded.clear();
        for (final ExternalAggregatedGroupMapping extGroup : extAggregatedGroupConfig.getExcludes()) {
            excluded.add(convert(extGroup));
        }
        //Copy over includes
        final Set<AggregatedGroupMapping> included = aggregatedGroupConfig.getIncluded();
        included.clear();
        for (final ExternalAggregatedGroupMapping extGroup : extAggregatedGroupConfig.getIncludes()) {
            included.add(convert(extGroup));
        }
        this.aggregationManagementDao.updateAggregatedGroupConfig(aggregatedGroupConfig);
    }
    //Delete interval configs that were not updated
    for (final AggregatedGroupConfig aggregatedGroupConfig : oldAggregatedGroupConfigs) {
        this.aggregationManagementDao.deleteAggregatedGroupConfig(aggregatedGroupConfig);
    }
    //Set quarter details if configured or set default quarters
    final List<ExternalQuarterDetail> extQuarterDetails = data.getQuarterDetails();
    final List<QuarterDetail> quarterDetails;
    if (!extQuarterDetails.isEmpty()) {
        quarterDetails = convertQuarterDetail(extQuarterDetails);
    } else {
        quarterDetails = EventDateTimeUtils.createStandardQuarters();
    }
    this.aggregationManagementDao.setQuarterDetails(quarterDetails);
    //Set academic term if configured
    final List<AcademicTermDetail> academicTerms = Lists.transform(data.getTermDetails(), new Function<ExternalTermDetail, AcademicTermDetail>() {

        public AcademicTermDetail apply(ExternalTermDetail externalTermDetail) {
            return new AcademicTermDetailImpl(new DateMidnight(externalTermDetail.getStart()), new DateMidnight(externalTermDetail.getEnd()), externalTermDetail.getName());
        }
    });
    this.aggregationManagementDao.setAcademicTermDetails(academicTerms);
}

Example 17 with AggregatedGroupMapping

use of org.apereo.portal.events.aggr.groups.AggregatedGroupMapping in project uPortal by Jasig.

the class EventAggregationConfigurationImporterExporter method exportData.

/*
     * (non-Javadoc)
     * @see org.apereo.portal.io.xml.IDataImporterExporter#exportData(java.lang.String)
     */
@Override
public ExternalEventAggregationConfiguration exportData(String id) {
    final ExternalEventAggregationConfiguration externalData = new ExternalEventAggregationConfiguration();
    //Copy interval configs
    final List<ExternalAggregatedIntervalConfig> aggregatedIntervalConfigs = externalData.getAggregatedIntervalConfigs();
    for (final AggregatedIntervalConfig aggregatedIntervalConfig : this.aggregationManagementDao.getAggregatedIntervalConfigs()) {
        final ExternalAggregatedIntervalConfig externalIntervalConfig = new ExternalAggregatedIntervalConfig();
        externalIntervalConfig.setAggregatorType(aggregatedIntervalConfig.getAggregatorType().getName());
        final List<ExternalAggregationInterval> extIncludes = externalIntervalConfig.getIncludes();
        for (final AggregationInterval interval : aggregatedIntervalConfig.getIncluded()) {
            extIncludes.add(convert(interval));
        }
        Collections.sort(extIncludes, EnumNameComparator.INSTANCE);
        final List<ExternalAggregationInterval> extExcludes = externalIntervalConfig.getExcludes();
        for (final AggregationInterval interval : aggregatedIntervalConfig.getExcluded()) {
            extExcludes.add(convert(interval));
        }
        Collections.sort(extExcludes, EnumNameComparator.INSTANCE);
        aggregatedIntervalConfigs.add(externalIntervalConfig);
    }
    Collections.sort(aggregatedIntervalConfigs, ExternalAggregatedDimensionConfigComparator.INSTANCE);
    //Copy group configs
    final List<ExternalAggregatedGroupConfig> aggregatedGroupConfigs = externalData.getAggregatedGroupConfigs();
    for (final AggregatedGroupConfig aggregatedGroupConfig : this.aggregationManagementDao.getAggregatedGroupConfigs()) {
        final ExternalAggregatedGroupConfig externalGroupConfig = new ExternalAggregatedGroupConfig();
        externalGroupConfig.setAggregatorType(aggregatedGroupConfig.getAggregatorType().getName());
        final List<ExternalAggregatedGroupMapping> extIncludes = externalGroupConfig.getIncludes();
        for (final AggregatedGroupMapping Group : aggregatedGroupConfig.getIncluded()) {
            extIncludes.add(convert(Group));
        }
        Collections.sort(extIncludes, ExternalAggregatedGroupMappingComparator.INSTANCE);
        final List<ExternalAggregatedGroupMapping> extExcludes = externalGroupConfig.getExcludes();
        for (final AggregatedGroupMapping Group : aggregatedGroupConfig.getExcluded()) {
            extExcludes.add(convert(Group));
        }
        Collections.sort(extExcludes, ExternalAggregatedGroupMappingComparator.INSTANCE);
        aggregatedGroupConfigs.add(externalGroupConfig);
    }
    Collections.sort(aggregatedGroupConfigs, ExternalAggregatedDimensionConfigComparator.INSTANCE);
    //Copy term details
    final List<ExternalTermDetail> externalTermDetails = externalData.getTermDetails();
    for (final AcademicTermDetail academicTermDetail : this.aggregationManagementDao.getAcademicTermDetails()) {
        final ExternalTermDetail externalTermDetail = new ExternalTermDetail();
        externalTermDetail.setName(academicTermDetail.getTermName());
        externalTermDetail.setStart(academicTermDetail.getStart().toGregorianCalendar());
        externalTermDetail.setEnd(academicTermDetail.getEnd().toGregorianCalendar());
        externalTermDetails.add(externalTermDetail);
    }
    Collections.sort(externalTermDetails, ExternalTermDetailComparator.INSTANCE);
    //Copy quarter details
    final List<ExternalQuarterDetail> quarterDetails = externalData.getQuarterDetails();
    for (final QuarterDetail quarterDetail : this.aggregationManagementDao.getQuartersDetails()) {
        final ExternalQuarterDetail externalQuarterDetail = new ExternalQuarterDetail();
        externalQuarterDetail.setId(quarterDetail.getQuarterId());
        externalQuarterDetail.setStart(quarterDetail.getStart().toString());
        externalQuarterDetail.setEnd(quarterDetail.getEnd().toString());
        quarterDetails.add(externalQuarterDetail);
    }
    Collections.sort(quarterDetails, ExternalQuarterDetailComparator.INSTANCE);
    return externalData;
}

Example 18 with AggregatedGroupMapping

use of org.apereo.portal.events.aggr.groups.AggregatedGroupMapping in project uPortal by Jasig.

the class ActivityController method buildPortalActivity.

private PortalActivity buildPortalActivity(PortletRequest request, int timeframe) {
    PortletPreferences prefs = request.getPreferences();
    DateTime begin, end;
    final AggregationInterval interval;
    final List<PortalGroupActivity> groupActivities = new ArrayList<PortalGroupActivity>();
    switch(timeframe) {
        case NOW:
            {
                end = new DateTime();
                begin = end.minusHours(1);
                interval = AggregationInterval.FIVE_MINUTE;
                break;
            }
        case TODAY:
            {
                begin = new DateMidnight().toDateTime();
                end = begin.plusDays(1);
                interval = AggregationInterval.DAY;
                break;
            }
        case YESTERDAY:
            {
                end = new DateMidnight().toDateTime().minusSeconds(1);
                begin = end.minusDays(1);
                interval = AggregationInterval.DAY;
                break;
            }
        default:
            {
                end = new DateTime();
                begin = end.minusHours(1);
                interval = AggregationInterval.HOUR;
                break;
            }
    }
    String masterGroup = prefs.getValue(PREFERENCE_MASTER_GROUP, DEFAULT_PREFERENCE_MASTER_GROUP);
    List<String> displayGroups = Arrays.asList(prefs.getValues(PREFERENCE_DISPLAY_GROUPS, DEFAULT_PREFERENCE_DISPLAY_GROUPS));
    boolean displayOther = Boolean.valueOf(prefs.getValue(PREFERENCE_DISPLAY_OTHER, DEFAULT_PREFERENCE_DISPLAY_OTHER));
    int masterTotal = 0;
    int absTotal = 0;
    int subTotal = 0;
    switch(timeframe) {
        case NOW:
            for (AggregatedGroupMapping group : concurrentUserAggregationDao.getAggregatedGroupMappings()) {
                ConcurrentUserAggregationKey key = new ConcurrentUserAggregationKeyImpl(interval, group);
                final List<ConcurrentUserAggregation> aggregations = concurrentUserAggregationDao.getAggregations(begin, end, key);
                // NB:  We only care about the most recent entry (??)
                if (aggregations.size() != 0) {
                    final ConcurrentUserAggregation aggregation = aggregations.get(0);
                    int groupTotal = aggregation.getConcurrentUsers();
                    absTotal += aggregation.getConcurrentUsers();
                    if (group.getGroupName().equalsIgnoreCase(masterGroup)) {
                        masterTotal = groupTotal;
                    } else {
                        subTotal += groupTotal;
                    }
                    if (!group.getGroupName().equals(masterGroup)) {
                        if (displayGroups.isEmpty() || displayGroups.contains(group.getGroupName())) {
                            final PortalGroupActivity groupActivity = new PortalGroupActivity(group.getGroupName(), groupTotal);
                            groupActivities.add(groupActivity);
                        }
                    }
                }
            }
            break;
        default:
            String uniqueLoginsPref = prefs.getValue(PREFERENCE_UNIQUE_LOGINS, DEFAULT_PREFERENCE_UNIQUE_LOGINS);
            Boolean uniqueLogins = Boolean.valueOf(uniqueLoginsPref);
            for (AggregatedGroupMapping group : loginAggregationDao.getAggregatedGroupMappings()) {
                final LoginAggregationKey key = new LoginAggregationKeyImpl(interval, group);
                final List<LoginAggregation> aggregations = loginAggregationDao.getAggregations(begin, end, key);
                // NB:  We only care about the most recent entry (??)
                if (aggregations.size() != 0) {
                    final LoginAggregation aggregation = aggregations.get(0);
                    int groupTotal = getAggregationLoginCount(aggregation, uniqueLogins);
                    absTotal += groupTotal;
                    if (group.getGroupName().equalsIgnoreCase(masterGroup)) {
                        masterTotal = groupTotal;
                    } else {
                        subTotal += groupTotal;
                    }
                    if (!group.getGroupName().equals(masterGroup)) {
                        if (displayGroups.isEmpty() || displayGroups.contains(group.getGroupName())) {
                            PortalGroupActivity groupActivity = new PortalGroupActivity(group.getGroupName(), groupTotal);
                            groupActivities.add(groupActivity);
                        }
                    }
                }
            }
            break;
    }
    if (displayOther) {
        int otherTotal = masterTotal - subTotal;
        if (otherTotal > 0) {
            PortalGroupActivity otherGroup = new PortalGroupActivity("Other", otherTotal);
            groupActivities.add(otherGroup);
        }
    }
    Collections.sort(groupActivities);
    Collections.reverse(groupActivities);
    int total = masterTotal > 0 ? masterTotal : absTotal;
    final PortalActivity activity = new PortalActivity(total, groupActivities);
    return activity;
}

Example 19 with AggregatedGroupMapping

use of org.apereo.portal.events.aggr.groups.AggregatedGroupMapping in project uPortal by Jasig.

the class JpaEventAggregationManagementDaoTest method testAggregatedGroupConfig.

@Test
public void testAggregatedGroupConfig() throws Exception {
    final IEntityGroup everyoneGroup = mock(IEntityGroup.class);
    when(everyoneGroup.getServiceName()).thenReturn(new CompositeName("local"));
    when(everyoneGroup.getName()).thenReturn("Everyone");
    when(compositeGroupService.findGroup("local.0")).thenReturn(everyoneGroup);
    this.execute(new CallableWithoutResult() {

        @Override
        protected void callWithoutResult() {
            final AggregatedGroupConfig defaultAggregatedGroupConfig = eventAggregationManagementDao.getDefaultAggregatedGroupConfig();
            assertNotNull(defaultAggregatedGroupConfig);
            assertEquals(0, defaultAggregatedGroupConfig.getExcluded().size());
            assertEquals(0, defaultAggregatedGroupConfig.getIncluded().size());
            AggregatedGroupConfig loginAggregatedGroupConfig = eventAggregationManagementDao.getAggregatedGroupConfig(LoginPortalEventAggregator.class);
            assertNull(loginAggregatedGroupConfig);
            loginAggregatedGroupConfig = eventAggregationManagementDao.createAggregatedGroupConfig(LoginPortalEventAggregator.class);
            assertNotNull(loginAggregatedGroupConfig);
            assertEquals(0, loginAggregatedGroupConfig.getExcluded().size());
            assertEquals(0, loginAggregatedGroupConfig.getIncluded().size());
            final AggregatedGroupMapping group = aggregatedGroupLookupDao.getGroupMapping("local.0");
            defaultAggregatedGroupConfig.getIncluded().add(group);
            loginAggregatedGroupConfig.getExcluded().add(group);
            eventAggregationManagementDao.updateAggregatedGroupConfig(defaultAggregatedGroupConfig);
            eventAggregationManagementDao.updateAggregatedGroupConfig(loginAggregatedGroupConfig);
        }
    });
    this.execute(new CallableWithoutResult() {

        @Override
        protected void callWithoutResult() {
            final AggregatedGroupConfig defaultAggregatedGroupConfig = eventAggregationManagementDao.getDefaultAggregatedGroupConfig();
            assertNotNull(defaultAggregatedGroupConfig);
            assertEquals(0, defaultAggregatedGroupConfig.getExcluded().size());
            assertEquals(1, defaultAggregatedGroupConfig.getIncluded().size());
            AggregatedGroupConfig loginAggregatedGroupConfig = eventAggregationManagementDao.getAggregatedGroupConfig(LoginPortalEventAggregator.class);
            assertNotNull(loginAggregatedGroupConfig);
            assertEquals(1, loginAggregatedGroupConfig.getExcluded().size());
            assertEquals(0, loginAggregatedGroupConfig.getIncluded().size());
            eventAggregationManagementDao.deleteAggregatedGroupConfig(defaultAggregatedGroupConfig);
            eventAggregationManagementDao.deleteAggregatedGroupConfig(loginAggregatedGroupConfig);
        }
    });
    this.execute(new CallableWithoutResult() {

        @Override
        protected void callWithoutResult() {
            final AggregatedGroupConfig defaultAggregatedGroupConfig = eventAggregationManagementDao.getDefaultAggregatedGroupConfig();
            assertNotNull(defaultAggregatedGroupConfig);
            assertEquals(0, defaultAggregatedGroupConfig.getExcluded().size());
            assertEquals(0, defaultAggregatedGroupConfig.getIncluded().size());
            AggregatedGroupConfig loginAggregatedGroupConfig = eventAggregationManagementDao.getAggregatedGroupConfig(LoginPortalEventAggregator.class);
            assertNull(loginAggregatedGroupConfig);
        }
    });
}

Example 20 with AggregatedGroupMapping

use of org.apereo.portal.events.aggr.groups.AggregatedGroupMapping in project uPortal by Jasig.

the class JpaBaseAggregationDaoTest method testBaseAggregationRangeQuery.

@Test
public final void testBaseAggregationRangeQuery() throws Exception {
    final IEntityGroup entityGroupA = mock(IEntityGroup.class);
    when(entityGroupA.getServiceName()).thenReturn(new CompositeName("local"));
    when(entityGroupA.getName()).thenReturn("Group A");
    when(compositeGroupService.findGroup("local.0")).thenReturn(entityGroupA);
    final IEntityGroup entityGroupB = mock(IEntityGroup.class);
    when(entityGroupB.getServiceName()).thenReturn(new CompositeName("local"));
    when(entityGroupB.getName()).thenReturn("Group B");
    when(compositeGroupService.findGroup("local.1")).thenReturn(entityGroupB);
    final MutableInt aggrs = new MutableInt();
    //Create 2 days of login aggregates ... every 5 minutes
    final DateTime start = new DateTime(1326734644000l, DateTimeZone.UTC).minuteOfDay().roundFloorCopy();
    final DateTime end = start.plusDays(2);
    final AggregationInterval interval = AggregationInterval.FIVE_MINUTE;
    final MutableObject startObj = new MutableObject();
    final MutableObject endObj = new MutableObject();
    this.executeInTransaction(new CallableWithoutResult() {

        @Override
        protected void callWithoutResult() {
            final Random r = new Random(0);
            final AggregatedGroupMapping groupA = aggregatedGroupLookupDao.getGroupMapping("local.0");
            final AggregatedGroupMapping groupB = aggregatedGroupLookupDao.getGroupMapping("local.1");
            populateDateTimeDimensions(start, end, new FunctionWithoutResult<Tuple<DateDimension, TimeDimension>>() {

                @Override
                protected void applyWithoutResult(Tuple<DateDimension, TimeDimension> input) {
                    final TimeDimension td = input.second;
                    final DateDimension dd = input.first;
                    final DateTime instant = td.getTime().toDateTime(dd.getDate());
                    if (startObj.getValue() == null) {
                        startObj.setValue(instant);
                    }
                    endObj.setValue(instant);
                    if (instant.equals(interval.determineStart(instant))) {
                        final AggregationIntervalInfo intervalInfo = aggregationIntervalHelper.getIntervalInfo(interval, instant);
                        final T baseAggregationA = getAggregationDao().createAggregation(createAggregationKey(intervalInfo, groupA));
                        final T baseAggregationB = getAggregationDao().createAggregation(createAggregationKey(intervalInfo, groupB));
                        for (int u = 0; u < r.nextInt(50); u++) {
                            updateAggregation(intervalInfo, baseAggregationA, r);
                            updateAggregation(intervalInfo, baseAggregationB, r);
                        }
                        baseAggregationA.intervalComplete(5);
                        baseAggregationB.intervalComplete(5);
                        getAggregationDao().updateAggregation(baseAggregationA);
                        getAggregationDao().updateAggregation(baseAggregationB);
                        aggrs.add(2);
                    }
                }
            });
        }
    });
    //Verify all aggrs created
    assertEquals(1152, aggrs.intValue());
    //Find aggrs for one day
    this.execute(new CallableWithoutResult() {

        @Override
        protected void callWithoutResult() {
            final AggregatedGroupMapping groupA = aggregatedGroupLookupDao.getGroupMapping("local.0");
            final AggregatedGroupMapping groupB = aggregatedGroupLookupDao.getGroupMapping("local.1");
            final DateTime queryStart = start.toDateMidnight().toDateTime();
            final DateTime queryEnd = queryStart.plusDays(1).minusSeconds(1);
            final List<T> baseAggregations = getAggregationDao().getAggregations(queryStart, queryEnd, createAggregationKey(interval, groupA), groupB);
            assertEquals(158, baseAggregations.size());
        }
    });
    //Find aggrs for second day
    this.execute(new CallableWithoutResult() {

        @Override
        protected void callWithoutResult() {
            final AggregatedGroupMapping groupA = aggregatedGroupLookupDao.getGroupMapping("local.0");
            final AggregatedGroupMapping groupB = aggregatedGroupLookupDao.getGroupMapping("local.1");
            final DateTime queryStart = start.toDateMidnight().minusDays(1).toDateTime();
            final DateTime queryEnd = queryStart.plusDays(2).minusSeconds(1);
            final List<T> baseAggregations = getAggregationDao().getAggregations(queryStart, queryEnd, createAggregationKey(interval, groupA), groupB);
            assertEquals(158, baseAggregations.size());
        }
    });
    //Find all aggrs
    this.execute(new CallableWithoutResult() {

        @Override
        protected void callWithoutResult() {
            final AggregatedGroupMapping groupA = aggregatedGroupLookupDao.getGroupMapping("local.0");
            final AggregatedGroupMapping groupB = aggregatedGroupLookupDao.getGroupMapping("local.1");
            final List<T> baseAggregations = getAggregationDao().getAggregations(start, end.plusDays(1), createAggregationKey(interval, groupA), groupB);
            assertEquals(1152, baseAggregations.size());
        }
    });
    //Find first days worth
    this.execute(new CallableWithoutResult() {

        @Override
        protected void callWithoutResult() {
            final AggregatedGroupMapping groupA = aggregatedGroupLookupDao.getGroupMapping("local.0");
            final AggregatedGroupMapping groupB = aggregatedGroupLookupDao.getGroupMapping("local.1");
            final List<T> baseAggregations = getAggregationDao().getAggregations(start, end, createAggregationKey(interval, groupA), groupB);
            assertEquals(1152, baseAggregations.size());
        }
    });
    //Find second days worth
    this.execute(new CallableWithoutResult() {

        @Override
        protected void callWithoutResult() {
            final AggregatedGroupMapping groupA = aggregatedGroupLookupDao.getGroupMapping("local.0");
            final AggregatedGroupMapping groupB = aggregatedGroupLookupDao.getGroupMapping("local.1");
            final List<T> baseAggregations = getAggregationDao().getAggregations(start.plusDays(1), end.plusDays(1), createAggregationKey(interval, groupA), groupB);
            assertEquals(576, baseAggregations.size());
        }
    });
    //Find first 12 hours worth
    this.execute(new CallableWithoutResult() {

        @Override
        protected void callWithoutResult() {
            final AggregatedGroupMapping groupA = aggregatedGroupLookupDao.getGroupMapping("local.0");
            final AggregatedGroupMapping groupB = aggregatedGroupLookupDao.getGroupMapping("local.1");
            final List<T> baseAggregations = getAggregationDao().getAggregations(start, start.plusHours(12), createAggregationKey(interval, groupA), groupB);
            assertEquals(288, baseAggregations.size());
        }
    });
    //Find middle 24 hours worth
    this.execute(new CallableWithoutResult() {

        @Override
        protected void callWithoutResult() {
            final AggregatedGroupMapping groupA = aggregatedGroupLookupDao.getGroupMapping("local.0");
            final AggregatedGroupMapping groupB = aggregatedGroupLookupDao.getGroupMapping("local.1");
            final List<T> baseAggregations = getAggregationDao().getAggregations(start.plusHours(12), end.plusHours(12), createAggregationKey(interval, groupA), groupB);
            assertEquals(864, baseAggregations.size());
        }
    });
    //Find middle 24 hours worth for one group
    this.execute(new CallableWithoutResult() {

        @Override
        protected void callWithoutResult() {
            final AggregatedGroupMapping groupA = aggregatedGroupLookupDao.getGroupMapping("local.0");
            final List<T> baseAggregations = getAggregationDao().getAggregations(start.plusHours(12), end.plusHours(12), createAggregationKey(interval, groupA));
            assertEquals(432, baseAggregations.size());
        }
    });
    //Find last 12 hours worth
    this.execute(new CallableWithoutResult() {

        @Override
        protected void callWithoutResult() {
            final AggregatedGroupMapping groupA = aggregatedGroupLookupDao.getGroupMapping("local.0");
            final AggregatedGroupMapping groupB = aggregatedGroupLookupDao.getGroupMapping("local.1");
            final List<T> baseAggregations = getAggregationDao().getAggregations(start.plusHours(36), end.plusDays(1), createAggregationKey(interval, groupA), groupB);
            assertEquals(288, baseAggregations.size());
        }
    });
    //TODO Query for intervals that are stored
    this.execute(new CallableWithoutResult() {

        @Override
        protected void callWithoutResult() {
            final Set<AggregatedGroupMapping> aggregatedGroupMappings = getAggregationDao().getAggregatedGroupMappings();
            assertEquals(2, aggregatedGroupMappings.size());
            final Set<AggregationInterval> aggregationIntervals = getAggregationDao().getAggregationIntervals();
            assertEquals(1, aggregationIntervals.size());
        }
    });
}