Java tutorial
/* * Copyright 2013, 2014, 2015 EnergyOS.org * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.energyos.espi.common.service.impl; import java.io.IOException; import java.io.OutputStream; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.UUID; import javax.servlet.ServletOutputStream; import javax.xml.transform.stream.StreamResult; import org.energyos.espi.common.domain.ApplicationInformation; import org.energyos.espi.common.domain.Authorization; import org.energyos.espi.common.domain.ElectricPowerQualitySummary; import org.energyos.espi.common.domain.ElectricPowerUsageSummary; import org.energyos.espi.common.domain.IdentifiedObject; import org.energyos.espi.common.domain.IntervalBlock; import org.energyos.espi.common.domain.MeterReading; import org.energyos.espi.common.domain.ReadingType; import org.energyos.espi.common.domain.RetailCustomer; import org.energyos.espi.common.domain.Routes; import org.energyos.espi.common.domain.Subscription; import org.energyos.espi.common.domain.TimeConfiguration; import org.energyos.espi.common.domain.UsagePoint; import org.energyos.espi.common.models.atom.DateTimeType; import org.energyos.espi.common.models.atom.EntryType; import org.energyos.espi.common.service.ApplicationInformationService; import org.energyos.espi.common.service.AuthorizationService; import org.energyos.espi.common.service.ElectricPowerQualitySummaryService; import org.energyos.espi.common.service.ElectricPowerUsageSummaryService; import org.energyos.espi.common.service.ExportService; import org.energyos.espi.common.service.IntervalBlockService; import org.energyos.espi.common.service.MeterReadingService; import org.energyos.espi.common.service.ReadingTypeService; import org.energyos.espi.common.service.ResourceService; import org.energyos.espi.common.service.RetailCustomerService; import org.energyos.espi.common.service.SubscriptionService; import org.energyos.espi.common.service.TimeConfigurationService; import org.energyos.espi.common.service.UsagePointService; import org.energyos.espi.common.utils.AtomMarshallerListener; import org.energyos.espi.common.utils.DateConverter; import org.energyos.espi.common.utils.EntryTypeIterator; import org.energyos.espi.common.utils.ExportFilter; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.oxm.jaxb.Jaxb2Marshaller; import org.springframework.stereotype.Service; @Service public class ExportServiceImpl implements ExportService { @Autowired private ResourceService resourceService; @Autowired private SubscriptionService subscriptionService; @Autowired private RetailCustomerService retailCustomerService; @Autowired private UsagePointService usagePointService; @Autowired private MeterReadingService meterReadingService; @Autowired private ReadingTypeService readingTypeService; @Autowired private IntervalBlockService intervalBlockService; @Autowired private ElectricPowerQualitySummaryService electricPowerQualitySummaryService; @Autowired private ElectricPowerUsageSummaryService electricPowerUsageSummaryService; @Autowired private AuthorizationService authorizationService; @Autowired private ApplicationInformationService applicationInformationService; @Autowired private TimeConfigurationService timeConfigurationService; @Autowired @Qualifier("fragmentMarshaller") private Jaxb2Marshaller fragmentMarshaller; // setup the services // public void setResourceService(ResourceService resourceService) { this.resourceService = resourceService; } public ResourceService getResourceService() { return this.resourceService; } public void setSubscriptionService(SubscriptionService subscriptionService) { this.subscriptionService = subscriptionService; } public SubscriptionService getSubscriptionService() { return this.subscriptionService; } public void setRetailCustomerService(RetailCustomerService retailCustomerService) { this.retailCustomerService = retailCustomerService; } public RetailCustomerService getRetailCustomerService() { return this.retailCustomerService; } public void setUsagePointService(UsagePointService usagePointService) { this.usagePointService = usagePointService; } public UsagePointService getUsagePointService() { return this.usagePointService; } public void setMeterReadingService(MeterReadingService meterReadingService) { this.meterReadingService = meterReadingService; } public MeterReadingService getMeterReadingService() { return this.meterReadingService; } public void setReadingTypeService(ReadingTypeService readingTypeService) { this.readingTypeService = readingTypeService; } public ReadingTypeService getReadingTypeService() { return this.readingTypeService; } public void setIntervalBlockService(IntervalBlockService intervalBlockService) { this.intervalBlockService = intervalBlockService; } public IntervalBlockService getIntervalBlockService() { return this.intervalBlockService; } public void setElectricPowerQualitySummaryService( ElectricPowerQualitySummaryService electricPowerQualitySummaryService) { this.electricPowerQualitySummaryService = electricPowerQualitySummaryService; } public ElectricPowerQualitySummaryService getElectricPowerQualitySummaryService() { return this.electricPowerQualitySummaryService; } public void setElectricPowerUsageSummaryService( ElectricPowerUsageSummaryService electricPowerUsageSummaryService) { this.electricPowerUsageSummaryService = electricPowerUsageSummaryService; } public ElectricPowerUsageSummaryService getElectricPowerUsageSummaryService() { return this.electricPowerUsageSummaryService; } public void setAuthorizationService(AuthorizationService authorizationService) { this.authorizationService = authorizationService; } public AuthorizationService getAuthorizationService() { return this.authorizationService; } public void setApplicationInformationService(ApplicationInformationService applicationInformationService) { this.applicationInformationService = applicationInformationService; } public ApplicationInformationService getApplicationInformationService() { return this.applicationInformationService; } public void setTimeConfigurationService(TimeConfigurationService timeConfigurationService) { this.timeConfigurationService = timeConfigurationService; } public TimeConfigurationService getTimeConfigurationService() { return this.timeConfigurationService; } public void setJaxb2Marshaller(Jaxb2Marshaller fragmentMarshaller) { this.fragmentMarshaller = fragmentMarshaller; } @Override public <T extends IdentifiedObject> void exportResource(Long resourceId, Class<T> clazz, OutputStream stream, ExportFilter exportFilter) { // TODO Auto-generated method stub } @Override public <T extends IdentifiedObject> void exportResources(Class<T> clazz, OutputStream stream, ExportFilter exportFilter) { // TODO Auto-generated method stub } // ApplicationInformation // - ROOT form @Override public void exportApplicationInformation(Long applicationInformationId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/ApplicationInformation/" + applicationInformationId; exportEntry(resourceService.findEntryType(applicationInformationId, ApplicationInformation.class), stream, exportFilter, hrefFragment); } @Override public void exportApplicationInformations(OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/ApplicationInformation"; exportEntries(resourceService.findEntryTypeIterator(ApplicationInformation.class), stream, exportFilter, ApplicationInformation.class, hrefFragment); } // Authorization // - ROOT form @Override public void exportAuthorization(Long authorizationId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Authorization/" + authorizationId; exportEntry(resourceService.findEntryType(authorizationId, Authorization.class), stream, exportFilter, hrefFragment); } @Override public void exportAuthorizations(OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Authorization"; exportEntries(resourceService.findEntryTypeIterator(Authorization.class), stream, exportFilter, Authorization.class, hrefFragment); } @Override public void exportAuthorizations(Authorization authorization, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Authorization"; exportEntries( resourceService.findEntryTypeIterator(authorizationService.findAllIdsByApplicationInformationId( authorization.getApplicationInformation().getId()), Authorization.class), stream, exportFilter, Authorization.class, hrefFragment); } // - XPath form @Override public void exportAuthorization(Long retailCustomerId, Long authorizationId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/RetailCustomer/" + retailCustomerId + "/Authorization/" + authorizationId; exportEntry(authorizationService.findEntryType(retailCustomerId, authorizationId), stream, exportFilter, hrefFragment); } @Override public void exportAuthorizations(Long retailCustomerId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/RetailCustomer/" + retailCustomerId + "/Authorization"; exportEntries(authorizationService.findEntryTypeIterator(retailCustomerId), stream, exportFilter, Authorization.class, hrefFragment); } // ElectricPowerQualitySummary // - ROOT form @Override public void exportElectricPowerQualitySummary_Root(Long subscriptionId, Long electricPowerQualitySummaryId, OutputStream stream, ExportFilter exportFilter) throws IOException { ElectricPowerQualitySummary electricPowerQualitySummary = resourceService .findById(electricPowerQualitySummaryId, ElectricPowerQualitySummary.class); UsagePoint usagePoint = electricPowerQualitySummary.getUsagePoint(); String hrefFragment = "/Subscription/" + subscriptionId + "/UsagePoint" + usagePoint.getId() + "/ElectricPowerQualitySummary/" + electricPowerQualitySummaryId; exportEntry(subscriptionId, resourceService.findEntryType(electricPowerQualitySummaryId, ElectricPowerQualitySummary.class), stream, exportFilter, hrefFragment); } @Override public void exportElectricPowerQualitySummarys_Root(Long subscriptionId, OutputStream stream, ExportFilter exportFilter) throws IOException { exportRootForm("/ElectricPowerQualitySummary", subscriptionId, stream, exportFilter, ElectricPowerQualitySummary.class); } // - XPath form @Override public void exportElectricPowerQualitySummary(Long subscriptionId, Long retailCustomerId, Long usagePointId, Long electricPowerQualitySummaryId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Subscription" + subscriptionId + "/UsagePoint/" + usagePointId + "/ElectricPowerQualitySummary/" + electricPowerQualitySummaryId; exportEntry(subscriptionId, electricPowerQualitySummaryService.findEntryType(retailCustomerId, usagePointId, electricPowerQualitySummaryId), stream, exportFilter, hrefFragment); } @Override public void exportElectricPowerQualitySummarys(Long subscriptionId, Long retailCustomerId, Long usagePointId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Subscription" + subscriptionId + "/UsagePoint/" + usagePointId + "/ElectricPowerQualitySummary"; exportEntries(subscriptionId, electricPowerQualitySummaryService.findEntryTypeIterator(retailCustomerId, usagePointId), stream, exportFilter, ElectricPowerQualitySummary.class, hrefFragment); } // ElectricPowerUsageSummary // - ROOT form @Override public void exportElectricPowerUsageSummarys_Root(Long subscriptionId, ServletOutputStream outputStream, ExportFilter exportFilter) throws IOException { exportRootForm("/ElectricPowerUsageSummary", subscriptionId, outputStream, exportFilter, ElectricPowerUsageSummary.class); } @Override public void exportElectricPowerUsageSummary_Root(Long subscriptionId, long electricPowerUsageSummaryId, ServletOutputStream stream, ExportFilter exportFilter) throws IOException { ElectricPowerUsageSummary electricPowerUsageSummary = resourceService.findById(electricPowerUsageSummaryId, ElectricPowerUsageSummary.class); UsagePoint usagePoint = electricPowerUsageSummary.getUsagePoint(); String hrefFragment = "/Subscription/" + subscriptionId + "/UsagePoint" + usagePoint.getId() + "/ElectricPowerUsageSummary/" + electricPowerUsageSummaryId; exportEntry(subscriptionId, resourceService.findEntryType(electricPowerUsageSummaryId, ElectricPowerUsageSummary.class), stream, exportFilter, hrefFragment); } // - XPath form @Override public void exportElectricPowerUsageSummary(Long subscriptionId, Long retailCustomerId, Long usagePointId, Long electricPowerUsageSummaryId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Subscription/" + subscriptionId + "/UsagePoint/" + usagePointId + "/ElectricPowerUsageSummary/" + electricPowerUsageSummaryId; exportEntry(subscriptionId, electricPowerUsageSummaryService.findEntryType(retailCustomerId, usagePointId, electricPowerUsageSummaryId), stream, exportFilter, hrefFragment); } @Override public void exportElectricPowerUsageSummarys(Long subscriptionId, Long retailCustomerId, Long usagePointId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Subscription/" + subscriptionId + "/UsagePoint/" + usagePointId + "/ElectricPowerUsageSummary"; exportEntries(subscriptionId, electricPowerUsageSummaryService.findEntryTypeIterator(retailCustomerId, usagePointId), stream, exportFilter, ElectricPowerUsageSummary.class, hrefFragment); } // IntervalBlock // - ROOT form @Override public void exportIntervalBlock_Root(Long subscriptionId, Long intervalBlockId, OutputStream stream, ExportFilter exportFilter) throws IOException { IntervalBlock intervalBlock = resourceService.findById(intervalBlockId, IntervalBlock.class); MeterReading meterReading = intervalBlock.getMeterReading(); UsagePoint usagePoint = meterReading.getUsagePoint(); String hrefFragment = "/Subscription/" + subscriptionId + "/UsagePoint/" + usagePoint.getId() + "/MeterReading/" + meterReading.getId() + "/IntervalBlock/" + intervalBlockId; exportEntry(subscriptionId, resourceService.findEntryType(intervalBlockId, IntervalBlock.class), stream, exportFilter, hrefFragment); } @Override public void exportIntervalBlocks_Root(Long subscriptionId, OutputStream stream, ExportFilter exportFilter) throws IOException { exportRootForm("/IntervalBlock", subscriptionId, stream, exportFilter, IntervalBlock.class); } // - XPath form @Override public void exportIntervalBlock(Long subscriptionId, Long retailCustomerId, Long usagePointId, Long meterReadingId, Long intervalBlockId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Subscription/" + subscriptionId + "/UsagePoint/" + usagePointId + "/IntervalBlock/" + intervalBlockId; exportEntry(subscriptionId, findEntryTypeXPath(subscriptionId, retailCustomerId, usagePointId, meterReadingId, intervalBlockId, IntervalBlock.class), stream, exportFilter, hrefFragment); } @Override public void exportIntervalBlocks(Long subscriptionId, Long retailCustomerId, Long usagePointId, Long meterReadingId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Subscription/" + subscriptionId + "/UsagePoint/" + usagePointId + "/IntervalBlock"; exportEntries( subscriptionId, findEntryTypeIteratorXPath(subscriptionId, retailCustomerId, usagePointId, meterReadingId, IntervalBlock.class), stream, exportFilter, IntervalBlock.class, hrefFragment); } // MeterReading // - ROOT form @Override public void exportMeterReadings_Root(Long subscriptionId, ServletOutputStream stream, ExportFilter exportFilter) throws IOException { exportRootForm("/MeterReading", subscriptionId, stream, exportFilter, MeterReading.class); } @Override public void exportMeterReading_Root(Long subscriptionId, long meterReadingId, ServletOutputStream stream, ExportFilter exportFilter) throws IOException { MeterReading meterReading = resourceService.findById(meterReadingId, MeterReading.class); UsagePoint usagePoint = meterReading.getUsagePoint(); String hrefFragment = "/Subscription/" + subscriptionId + "/UsagePoint/" + usagePoint.getId() + "/MeterReading/" + meterReadingId; exportEntry(subscriptionId, resourceService.findEntryType(meterReadingId, MeterReading.class), stream, exportFilter, hrefFragment); } // - XPath @Override public void exportMeterReading(Long subscriptionId, Long retailCustomerId, Long usagePointId, Long meterReadingId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Subscription/" + subscriptionId + "/UsagePoint/" + usagePointId + "/MeterReading/" + meterReadingId; exportEntry(subscriptionId, findEntryTypeXPath(subscriptionId, retailCustomerId, usagePointId, meterReadingId, 0L, MeterReading.class), stream, exportFilter, hrefFragment); } @Override public void exportMeterReadings(Long subscriptionId, Long retailCustomerId, Long usagePointId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Subscription/" + subscriptionId + "/UsagePoint/" + usagePointId + "/MeterReading"; exportEntries(subscriptionId, findEntryTypeIteratorXPath(subscriptionId, retailCustomerId, usagePointId, 0L, MeterReading.class), stream, exportFilter, MeterReading.class, hrefFragment); } // ReadingType // ROOT form @Override public void exportReadingType(Long readingTypeId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/ReadingType/" + readingTypeId; exportEntry(resourceService.findEntryType(readingTypeId, ReadingType.class), stream, exportFilter, hrefFragment); } @Override public void exportReadingTypes(OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/ReadingType"; exportEntries(resourceService.findEntryTypeIterator(ReadingType.class), stream, exportFilter, ReadingType.class, hrefFragment); } // RetailCustomer // ROOT form @Override public void exportRetailCustomer(Long subscriptionId, Long retailCustomerId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/RetailCustomer/" + retailCustomerId; exportEntry(findEntryTypeXPath(subscriptionId, retailCustomerId, 0L, 0L, 0L, RetailCustomer.class), stream, exportFilter, hrefFragment); } @Override public void exportRetailCustomers(Long subscriptionId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/RetailCustomer"; exportEntries(findEntryTypeIteratorXPath(0L, 0L, 0L, 0L, RetailCustomer.class), stream, exportFilter, UsagePoint.class, hrefFragment); } // Subscription // - Root form @Override public void exportSubscription(Long subscriptionId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Subscription/" + subscriptionId; exportEntry(resourceService.findEntryType(subscriptionId, Subscription.class), stream, exportFilter, hrefFragment); } @Override public void exportSubscriptions(OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Subscription"; exportEntries(resourceService.findEntryTypeIterator(Subscription.class), stream, exportFilter, RetailCustomer.class, hrefFragment); } // - XPath form @Override public void exportSubscription(Long retailCustomerId, Long subscriptionId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/RetailCustomer/ + retailCustomerId + " + "/Subscription/" + subscriptionId; exportEntry(subscriptionService.findEntryType(retailCustomerId, subscriptionId), stream, exportFilter, hrefFragment); } @Override public void exportSubscriptions(Long retailCustomerId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/RetailCustomer/" + retailCustomerId + "/Subscription"; exportEntries(subscriptionService.findEntryTypeIterator(retailCustomerId), stream, exportFilter, RetailCustomer.class, hrefFragment); } // TimeConfiguration // - ROOT form @Override public void exportTimeConfiguration(Long timeConfigurationId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/LocalTimeParameters/" + timeConfigurationId; exportEntry(resourceService.findEntryType(timeConfigurationId, TimeConfiguration.class), stream, exportFilter, hrefFragment); } @Override public void exportTimeConfigurations(OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/LocalTimeParameters"; exportEntries(resourceService.findEntryTypeIterator(TimeConfiguration.class), stream, exportFilter, TimeConfiguration.class, hrefFragment); } // UsagePoints // // ROOT form @Override public void exportUsagePoint_Root(Long subscriptionId, Long usagePointId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Subscription/" + subscriptionId + "/UsagePoint/" + usagePointId; exportEntry(subscriptionId, resourceService.findEntryType(usagePointId, UsagePoint.class), stream, exportFilter, hrefFragment); } @Override public void exportUsagePoints_Root(Long subscriptionId, OutputStream stream, ExportFilter exportFilter) throws IOException { exportRootForm("/UsagePoint", subscriptionId, stream, exportFilter, UsagePoint.class); } // XPath form @Override public void exportUsagePoint(Long subscriptionId, Long retailCustomerId, Long usagePointId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Subscription/" + subscriptionId + "/UsagePoint/" + usagePointId; exportEntry(subscriptionId, findEntryTypeXPath(subscriptionId, retailCustomerId, usagePointId, 0L, 0L, UsagePoint.class), stream, exportFilter, hrefFragment); } @Override public void exportUsagePoints(Long subscriptionId, Long retailCustomerId, OutputStream stream, ExportFilter exportFilter) throws IOException { // here we need to get only a subset of the usagepoints are obtained String hrefFragment = "/Subscription/" + subscriptionId + "/UsagePoint"; exportEntries(subscriptionId, findEntryTypeIteratorXPath(subscriptionId, retailCustomerId, 0L, 0L, UsagePoint.class), stream, exportFilter, UsagePoint.class, hrefFragment); } // Special forms for Subscription, Bulk, Download // // -- original Pivotal export function (used in pub/sub flow) @Override public void exportSubscription(String subscriptionHashedId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Subscription/" + subscriptionHashedId; exportEntriesFull(subscriptionService.findEntriesByHashedId(subscriptionHashedId), stream, exportFilter, hrefFragment); } @Override public void exportBatchSubscription(Long subscriptionId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Batch/Subscription/" + subscriptionId; // first find all the usagePointIds this subscription is related to List<Long> usagePointIdList = subscriptionService.findUsagePointIds(subscriptionId); exportEntriesFull(subscriptionId, resourceService.findEntryTypeIterator(usagePointIdList, UsagePoint.class), stream, exportFilter, hrefFragment); } @Override public void exportBatchSubscriptionUsagePoint(Long subscriptionId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Batch/Subscription/" + subscriptionId + "/UsagePoint"; // first find all the usagePointIds this subscription is related to List<Long> usagePointIdList = subscriptionService.findUsagePointIds(subscriptionId); exportEntriesFull(subscriptionId, resourceService.findEntryTypeIterator(usagePointIdList, UsagePoint.class), stream, exportFilter, hrefFragment); } @Override public void exportBatchSubscriptionUsagePoint(Long subscriptionId, Long usagePointId, OutputStream stream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Batch/Subscription/" + subscriptionId + "/UsagePoint/" + usagePointId; List<Long> usagePointIdList = new ArrayList<Long>(); List<Long> temp = subscriptionService.findUsagePointIds(subscriptionId); if (temp.contains(usagePointId)) { usagePointIdList.add(usagePointId); } exportEntriesFull(subscriptionId, resourceService.findEntryTypeIterator(usagePointIdList, UsagePoint.class), stream, exportFilter, hrefFragment); } @Override public void exportBatchBulk(Long bulkId, String thirdParty, OutputStream outputStream, ExportFilter exportFilter) throws IOException { String hrefFragment = "/Batch/Bulk/" + bulkId; List<Long> usagePoints = new ArrayList<Long>(); List<Long> authorizations = authorizationService.findAllIdsByBulkId(thirdParty, bulkId); for (Long authorizationId : authorizations) { Subscription subscription = subscriptionService.findByAuthorizationId(authorizationId); for (UsagePoint up : subscription.getUsagePoints()) { usagePoints.add(up.getId()); } } exportEntriesFull(resourceService.findEntryTypeIterator(usagePoints, UsagePoint.class), outputStream, exportFilter, hrefFragment); } // export full usage point object tree (Download My Data) // @Override public void exportUsagePointsFull(Long subscriptionId, Long retailCustomerId, ServletOutputStream outputStream, ExportFilter exportFilter) throws IOException { // TODO right now subscriptionId is 1- ... String hrefFragment = "/Batch/RetailCustomer/" + retailCustomerId; exportEntriesFull(subscriptionId, usagePointService.findEntryTypeIterator(retailCustomerId), outputStream, exportFilter, hrefFragment); } @Override public void exportUsagePointFull(Long subscriptionId, Long retailCustomerId, Long usagePointId, ServletOutputStream outputStream, ExportFilter exportFilter) throws IOException { // TODO right now subscriptionId is 1- ... String hrefFragment = "/Batch/RetailCustomer/" + retailCustomerId + "/UsagePoint/" + usagePointId; exportEntriesFull(subscriptionId, usagePointService.findEntryTypeIterator(retailCustomerId, usagePointId), outputStream, exportFilter, hrefFragment); } // worker functions // private void buildHeader(OutputStream stream, String hrefFragment) throws IOException { // TODO Remove the ApplicationInformation(1L) dependency String dataCustodianResourceEndpoint = resourceService.findById(1L, ApplicationInformation.class) .getDataCustodianResourceEndpoint(); String selfRef = "<link href=\"" + dataCustodianResourceEndpoint + hrefFragment + "\" rel=\"self\"/>"; DateTimeType updated = DateConverter.toDateTimeType(new Date()); String temp = updated.getValue().toXMLFormat(); String uuid = UUID.randomUUID().toString(); String certLink = "<link href=\"https://cert.greenbuttonalliance.org/certificate/" + Routes.GBA_CERT_ID + "\" rel=\"related\"/>\n"; stream.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n".getBytes()); stream.write("<?xml-stylesheet type=\"text/xsl\" href=\"GreenButtonDataStyleSheet.xslt\"?>\n".getBytes()); stream.write( "<feed xmlns=\"http://www.w3.org/2005/Atom\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\">\n" .getBytes()); stream.write("<id>urn:uuid:".getBytes()); stream.write(uuid.getBytes()); stream.write("</id>\n".getBytes()); stream.write(certLink.getBytes()); stream.write("<title>Green Button Usage Feed</title>\n".getBytes()); stream.write("<updated>".getBytes()); stream.write(temp.getBytes()); stream.write("</updated>\n".getBytes()); stream.write(selfRef.getBytes()); } @SuppressWarnings({ "rawtypes" }) private void exportEntries(EntryTypeIterator entries, OutputStream stream, ExportFilter exportFilter, Class resourceClass, String hrefFragment) throws IOException { exportEntries(0L, entries, stream, exportFilter, resourceClass, hrefFragment); } @SuppressWarnings({ "rawtypes", "unchecked" }) private void exportEntries(Long subscriptionId, EntryTypeIterator entries, OutputStream stream, ExportFilter exportFilter, Class resourceClass, String hrefFragment) throws IOException { buildHeader(stream, hrefFragment); // hrefFragment = adjustFragment(hrefFragment); if (entries != null) { while (entries.hasNext()) { try { EntryType entry = entries.nextEntry(resourceClass); // export the Entry and put the right tail on the URI exportEntry(subscriptionId, entry, stream, exportFilter, hrefFragment + "/" + entry.getContent().getContentId(resourceClass)); } catch (Exception e) { System.out.printf("exportEntries: The requested collection contains no resources: %s: %s\n", hrefFragment, resourceClass.getSimpleName()); // stream.write("</feed>".getBytes()); } } } stream.write("</feed>".getBytes()); } @SuppressWarnings({ "rawtypes" }) private void exportRootForm(String hrefFragment, Long subscriptionId, OutputStream stream, ExportFilter exportFilter, Class targetClass) throws IOException { // Subscription subscription = subscriptionService // .findById(subscriptionId); // Authorization authorization = subscription.getAuthorization(); buildHeader(stream, hrefFragment); // start the recursion exportRootForm_Internal("/Subscription/" + subscriptionId, subscriptionId, Long.valueOf(0L), Long.valueOf(0L), Long.valueOf(0L), resourceService.findAllIds(UsagePoint.class), UsagePoint.class, targetClass, stream, exportFilter); stream.write("</feed>\n".getBytes()); } @SuppressWarnings({ "rawtypes", "unchecked" }) private void exportRootForm_Internal(String workingFragment, Long subscriptionId, Long retailCustomerId, Long usagePointId, Long meterReadingId, List<Long> resourceList, Class currentClass, Class targetClass, OutputStream stream, ExportFilter exportFilter) { List<Long> nextResourceList = new ArrayList<Long>(); if (targetClass.equals(currentClass)) { // we are at the end; build the final fragment and export this leaf // of the tree workingFragment = workingFragment + "/" + targetClass.getName(); try { exportEntries_Root(subscriptionId, resourceService.findEntryTypeIterator(resourceList, targetClass), stream, exportFilter, targetClass, workingFragment); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } else { for (Long id : resourceList) { if (currentClass.equals(UsagePoint.class)) { usagePointId = id; RetailCustomer retailCustomer = (resourceService.findById(usagePointId, UsagePoint.class)) .getRetailCustomer(); if (retailCustomer != null) { retailCustomerId = retailCustomer.getId(); } if (!(targetClass.equals(IntervalBlock.class))) { // this covers /ElectricPowerUsageSummary // /ElectricPowerQualitySummary and /MeterReading nextResourceList = resourceService.findAllIdsByXPath(retailCustomerId, id, targetClass); exportRootForm_Internal(workingFragment + "/UsagePoint/" + usagePointId, subscriptionId, retailCustomerId, usagePointId, meterReadingId, nextResourceList, targetClass, targetClass, stream, exportFilter); } else { // this covers /IntervalBlock for (Long id2 : resourceService.findAllIdsByXPath(retailCustomerId, id, MeterReading.class)) { nextResourceList = resourceService.findAllIdsByXPath(retailCustomerId, usagePointId, id2, IntervalBlock.class); exportRootForm_Internal(workingFragment + "/MeterReading/" + id2, subscriptionId, retailCustomerId, usagePointId, id2, nextResourceList, IntervalBlock.class, targetClass, stream, exportFilter); } } } } } } @SuppressWarnings({ "rawtypes", "unchecked" }) // TODO: this needs to be templated and RetailCustomer inherited from // IdentifiedObject to remove the above suppress warnings private void exportEntries_Root(Long subscriptionId, EntryTypeIterator entries, OutputStream stream, ExportFilter exportFilter, Class resourceClass, String hrefFragment) throws IOException { // hrefFragment = adjustFragment(hrefFragment); if (entries != null) { while (entries.hasNext()) { try { EntryType entry = entries.nextEntry(resourceClass); // export the Entry and put the right tail on the URI exportEntry(subscriptionId, entry, stream, exportFilter, hrefFragment + "/" + entry.getContent().getContentId(resourceClass)); } catch (Exception e) { System.out.printf( "exportEntries_Root: The requested collection contains no resources: %s: %s\n", hrefFragment, resourceClass.getSimpleName()); // stream.write("</feed>\n".getBytes()); } } } } private String adjustFragment(String fragment, EntryType entry) { String result = fragment; if (fragment.contains("DownloadMyData")) { result.replace("DownloadMyData", "UsagePoint"); } if (fragment.contains("Batch")) { if (fragment.contains("Bulk")) { UsagePoint up = entry.getContent().getUsagePoint(); RetailCustomer rc = up.getRetailCustomer(); result = "/RetailCustomer/" + rc.getId() + "/UsagePoint"; } // if (fragment.contains("Subscription")) { // the entry contains a valid usage point at this stage // // with the RetailCustomer -> Subscription change this should go // away // UsagePoint up = entry.getContent().getUsagePoint(); // RetailCustomer rc = up.getRetailCustomer(); // // result = "/RetailCustomer/" + rc.getId() + "/UsagePoint"; // } if (fragment.contains("/Batch/RetailCustomer")) { result = fragment.replace("/Batch", ""); if (!(fragment.contains("/UsagePoint"))) { result = result + "/UsagePoint"; } } } return result; } // to export a single entry (w/o the <feed>...</feed> wrappers private void exportEntry(EntryType entry, OutputStream stream, ExportFilter exportFilter, String hrefFragment) throws IOException { exportEntry(0L, entry, stream, exportFilter, hrefFragment); } private void exportEntry(Long subscriptionId, EntryType entry, OutputStream stream, ExportFilter exportFilter, String hrefFragment) throws IOException { // TODO Remove the ApplicationInformation(1L) dependency String dataCustodianResourceEndpoint = (resourceService.findById(1L, ApplicationInformation.class)) .getDataCustodianResourceEndpoint(); AtomMarshallerListener uriListener = new AtomMarshallerListener( dataCustodianResourceEndpoint + hrefFragment); uriListener.setRelList( entry.getContent().buildRelHref(subscriptionId, dataCustodianResourceEndpoint + hrefFragment)); uriListener.setSubscriptionId(subscriptionId); fragmentMarshaller.setMarshallerListener(uriListener); StreamResult result = new StreamResult(stream); try { if (exportFilter.matches(entry)) { fragmentMarshaller.marshal(entry, result); } } catch (Exception e) { throw (e); } } private void exportEntriesInternal(Long subscriptionId, EntryTypeIterator entries, OutputStream stream, ExportFilter exportFilter, String hrefFragment) throws IOException { while (entries.hasNext() == true) { try { EntryType entry = entries.next(); // last minute fixup b/f doing the full dump // changing self of the feed to self of the root resource // if (entry.getContent().getUsagePoint() != null) { hrefFragment = adjustFragment(hrefFragment, entry); } exportEntryFull(subscriptionId, entry, stream, exportFilter, hrefFragment); } catch (Exception e) { System.out.printf("exportEntriesInternal: The requested collection contains no resources: %s\n", hrefFragment); } } } // private void exportEntriesFull(List<EntryTypeIterator> bulkSubscriptions, // OutputStream stream, ExportFilter exportFilter, String hrefFragment) // throws IOException { // // buildHeader(stream, hrefFragment); // // for (EntryTypeIterator eti : bulkSubscriptions) { // // Long subscriptionId = eti.getSubscriptionId(); // // first set up the hrefFragment correctly // String temp = hrefFragment; // temp = temp.substring(temp.indexOf("/Bulk")); // temp = temp + "/Subscription/" + subscriptionId; // exportEntriesInternal(subscriptionId, eti, stream, exportFilter, // temp); // } // // stream.write("</feed>\n".getBytes()); // } private void exportEntriesFull(EntryTypeIterator entries, OutputStream stream, ExportFilter exportFilter, String hrefFragment) throws IOException { exportEntriesFull(0L, entries, stream, exportFilter, hrefFragment); } private void exportEntriesFull(Long subscriptionId, EntryTypeIterator entries, OutputStream stream, ExportFilter exportFilter, String hrefFragment) throws IOException { buildHeader(stream, hrefFragment); exportEntriesInternal(subscriptionId, entries, stream, exportFilter, hrefFragment); stream.write("</feed>".getBytes()); } // to export a single entry (w/o the <feed>...</feed> wrappers // private void exportEntryFull(EntryType entry, OutputStream stream, // ExportFilter exportFilter, String hrefFragment) throws IOException { // exportEntryFull(0L, entry, stream, exportFilter, hrefFragment); // } private void exportEntryFull(Long subscriptionId, EntryType entry, OutputStream stream, ExportFilter exportFilter, String hrefFragment) throws IOException { // TODO Remove the ApplicationInformation(1L) dependency String dataCustodianResourceEndpoint = resourceService.findById(1L, ApplicationInformation.class) .getDataCustodianResourceEndpoint(); // setup a listener so that the adapters may later be fed the fragment; // AtomMarshallerListener uriListener = new AtomMarshallerListener( dataCustodianResourceEndpoint + hrefFragment); uriListener.setRelList( entry.getContent().buildRelHref(subscriptionId, dataCustodianResourceEndpoint + hrefFragment)); uriListener.setSubscriptionId(subscriptionId); fragmentMarshaller.setMarshallerListener(uriListener); StreamResult result = new StreamResult(stream); try { if (exportFilter.matches(entry)) { fragmentMarshaller.marshal(entry, result); } } catch (Exception e) { throw (e); } } @SuppressWarnings("unchecked") // TODO: need to make RetailCustomer inherit from IdentifiedObject to remove // the above private EntryType findEntryTypeXPath(Long subscriptionId, Long id1, Long id2, Long id3, Long id4, @SuppressWarnings("rawtypes") Class clazz) { EntryType result = null; List<Long> temp = new ArrayList<Long>(); Subscription subscription = null; try { if (subscriptionId != 0) { subscription = resourceService.findById(subscriptionId, Subscription.class); Authorization authorization = subscription.getAuthorization(); if (!(authorization.getThirdParty().contentEquals("third_party"))) { // a special case (client credentials base) access. So the // retailCustomerId is not // correct if (id2 != 0) { // we have a request for (at least) a usagePoint // so use the relevant retail customer Id to get the ID // collection UsagePoint usagePoint = resourceService.findById(id2, UsagePoint.class); id1 = usagePoint.getRetailCustomer().getId(); } } } if (id4 != 0) { temp.add(resourceService.findIdByXPath(id1, id2, id3, id4, clazz)); } else { if (id3 != 0) { temp.add(resourceService.findIdByXPath(id1, id2, id3, clazz)); } else { if (id2 != 0) { temp.add(resourceService.findIdByXPath(id1, id2, clazz)); } else { temp.add(resourceService.findIdByXPath(id1, clazz)); } } } result = null; } catch (Exception e) { System.out.printf("**** Error in Query: %s\n", e.toString()); result = null; } if (temp != null) { result = (new EntryTypeIterator(resourceService, temp, clazz)).nextEntry(clazz); } return result; } @SuppressWarnings({ "rawtypes", "unchecked" }) // TODO: need to make RetailCustomer inherit from IdentifiedObject to remove // the above @Suppress private EntryTypeIterator findEntryTypeIteratorXPath(Long subscriptionId, Long id1, Long id2, Long id3, Class clazz) { EntryTypeIterator result = null; List<Long> temp = new ArrayList<Long>(); Subscription subscription = null; boolean valid = false; try { if (!(subscriptionId.equals(0L))) { subscription = resourceService.findById(subscriptionId, Subscription.class); Authorization authorization = subscription.getAuthorization(); if (!(authorization.getThirdParty().contentEquals("third_party"))) { // a special case (client credentials base) access. So the // retailCustomerId is not // correct if (id2 != 0) { // we have a request for (at least) a usagePoint // so use the relevant retail customer Id to get the ID // collection UsagePoint usagePoint = resourceService.findById(id2, UsagePoint.class); id1 = usagePoint.getRetailCustomer().getId(); } } } // do we have a usagepointId? if (!(id2.equals(0L))) { // is it in the subscription? for (UsagePoint up : subscription.getUsagePoints()) { if (up.getId().equals(id2)) { valid = true; } } } else { // we don't have a usagePoint, so it is all usage points in the // subscription valid = true; } if (valid) { if (!(id3.equals(0L))) { temp = resourceService.findAllIdsByXPath(id1, id2, id3, clazz); } else { if (!(id2.equals(0L))) { temp = resourceService.findAllIdsByXPath(id1, id2, clazz); } else { if (!(id1.equals(0L))) { // temp = resourceService.findAllIdsByXPath(id1, // clazz); // we just want the UsagePoints in the Subscription for (UsagePoint up : subscription.getUsagePoints()) { temp.add(up.getId()); } } else { // otherwise, just get all the RetailCustomers temp = resourceService.findAllIdsByXPath(RetailCustomer.class); } } } } result = (new EntryTypeIterator(resourceService, temp, clazz)); } catch (Exception e) { System.out.printf("**** Error in Query: %s\n", e.toString()); result = null; } return result; } }