public static String extractType(String id) { return extractType(id, null); }
@Override public DatasetOutput<V> setId(String id) { String type = getIfSet(valueType, true); super.setId(ValueType.createId(type, id)); return this; }
@Override public String getId() { return ValueType.extractId(super.getId()); }
@Override public boolean exists(String id, DbQuery parameters) throws DataAccessException { Session session = getSession(); try { String dbId = ValueType.extractId(id); String handleAsFallback = parameters.getHandleAsValueTypeFallback(); String valueType = ValueType.extractType(id, handleAsFallback); if (!dataRepositoryFactory.isKnown(valueType)) { return false; } DataRepository dataRepository = dataRepositoryFactory.create(valueType); DatasetDao<? extends DatasetEntity> dao = getDatasetDao(valueType, session); Class datasetEntityType = dataRepository.getDatasetEntityType(); return parameters.getParameters().isMatchDomainIds() ? dao.hasInstance(dbId, parameters, datasetEntityType) : dao.hasInstance(parseId(dbId), parameters, datasetEntityType); } catch (DatasetFactoryException ex) { throwNewCreateFactoryException(ex); return false; } finally { returnSession(session); } }
public static String createId(String type, String id) { if (id == null) { throw new NullPointerException("Cannot create from null id."); } if (id.isEmpty()) { throw new IllegalArgumentException("Cannot create from empty id."); } return assertNotNullOrEmpty(type) ? type.toLowerCase().concat(SEPERATOR).concat(id) : id; }
private String getValueType(IoParameters parameters) { String handleAs = parameters.getOther(Parameters.HANDLE_AS_VALUE_TYPE); Set<String> datasetIds = parameters.getDatasets(); Iterator<String> iterator = datasetIds.iterator(); return iterator.hasNext() ? ValueType.extractType(iterator.next(), handleAs) : ValueType.DEFAULT_VALUE_TYPE; }
public Set<String> getResultTimeList(IoParameters parameters, String datasetId) { return repository.getExtras(ValueType.extractId(datasetId), parameters); }
@RequestMapping(value = "/{timeseriesId}/{chartQualifier}", produces = { Constants.IMAGE_PNG }, method = RequestMethod.GET) public void getChartByInterval(HttpServletResponse response, @PathVariable String timeseriesId, @PathVariable String chartQualifier, @RequestHeader(value = Parameters.HttpHeader.ACCEPT_LANGUAGE, required = false) String locale, @RequestParam(required = false) MultiValueMap<String, String> request) throws Exception { if (preRenderingTask == null /*|| isHandlingPreRenderingTask()*/) { throw new ResourceNotFoundException("Diagram prerendering is not enabled."); } // XXX fix task setup/config String datasetId = ValueType.createId(ValueType.DEFAULT_VALUE_TYPE, timeseriesId); if (!preRenderingTask.hasPrerenderedImage(datasetId, chartQualifier)) { throw new ResourceNotFoundException("No pre-rendered chart found for timeseries '" + timeseriesId + "'."); } preRenderingTask.writePrerenderedGraphToOutputStream(datasetId, chartQualifier, response.getOutputStream()); }
public String getValueType() { String handleAs = getAsString(Parameters.HANDLE_AS_VALUE_TYPE); String[] datasetIds = getDatasets(); return datasetIds.length > 0 ? ValueType.extractType(datasetIds[0], handleAs) : ValueType.DEFAULT_VALUE_TYPE; }
DatasetEntity getInstanceEntity(String id, DbQuery query, Session session) throws DataAccessException { String rawId = ValueType.extractId(id); DatasetDao<? extends DatasetEntity> dao = getSeriesDao(id, query, session); DatasetEntity instance = dao.getInstance(Long.parseLong(rawId), query); instance.setPlatform(platformRepository.getPlatformEntity(instance, query, session)); return instance; }
private DatasetDao<? extends DatasetEntity> getSeriesDao(String datasetId, DbQuery query, Session session) throws DataAccessException { String handleAsFallback = query.getHandleAsValueTypeFallback(); final String valueType = ValueType.extractType(datasetId, handleAsFallback); if (!dataRepositoryFactory.isKnown(valueType)) { throw new ResourceNotFoundException("unknown type: " + valueType); } return createDataAccessRepository(valueType, session); }
Map<String, Set<HierarchicalParameterOutput>> getExtras(String platformId, IoParameters parameters) { Session session = getSession(); try { DbQuery dbQuery = getDbQuery(parameters); Map<String, Set<HierarchicalParameterOutput>> extras = new HashMap<>(); PlatformOutput platform = platformRepository.getInstance(platformId, dbQuery); DatasetDao<DatasetEntity> dao = new DatasetDao<>(session); for (DatasetOutput dataset : platform.getDatasets()) { String datasetId = ValueType.extractId(dataset.getId()); DatasetEntity instance = dao.getInstance(Long.parseLong(datasetId), dbQuery); addProcedureParents(instance, dbQuery, extras); // TODO add further parents } return extras; } catch (NumberFormatException e) { LOGGER.debug("Could not convert id '{}' to long.", platformId, e); } catch (DataAccessException e) { LOGGER.error("Could not query hierarchical parameters for dataset with id '{}'", platformId, e); } finally { returnSession(session); } return Collections.emptyMap(); }
private Data<AbstractValue< ? >> getDataFor(String datasetId, IoParameters parameters) throws DataAccessException { DbQuery dbQuery = dbQueryFactory.createFrom(parameters); String handleAsDatasetFallback = parameters.getAsString(Parameters.HANDLE_AS_VALUE_TYPE); String valueType = ValueType.extractType(datasetId, handleAsDatasetFallback); DataRepository dataRepository = createRepository(valueType); return dataRepository.getData(datasetId, dbQuery); }
@Override public Data< ? extends AbstractValue< ? >> getData(String datasetId, DbQuery dbQuery) throws DataAccessException { Session session = getSession(); try { String id = ValueType.extractId(datasetId); DatasetDao<S> seriesDao = getSeriesDao(session); IoParameters parameters = dbQuery.getParameters(); // remove spatial filter on metadata S series = seriesDao.getInstance(id, getDbQuery(parameters.removeAllOf(Parameters.BBOX) .removeAllOf(Parameters.NEAR) .removeAllOf(Parameters.ODATA_FILTER))); if (series.getService() == null) { series.setService(getServiceEntity()); } return dbQuery.isExpanded() ? assembleDataWithReferenceValues(series, dbQuery, session) : assembleData(series, dbQuery, session); } finally { returnSession(session); } }
@RequestMapping(value = "/{datasetId}/data", produces = { Constants.IMAGE_PNG }, method = RequestMethod.GET) public void getSeriesChart(HttpServletResponse response, @PathVariable String datasetId, @RequestHeader(value = Parameters.HttpHeader.ACCEPT_LANGUAGE, required = false) String locale, @RequestParam(required = false) MultiValueMap<String, String> query) throws Exception { IoParameters parameters = createParameters(datasetId, query, locale); LOGGER.debug("get data collection chart for '{}' with query: {}", datasetId, parameters); checkAgainstTimespanRestriction(parameters.getTimespan()); checkForUnknownDatasetId(parameters, datasetId); String handleAsValueTypeFallback = parameters.getAsString(Parameters.HANDLE_AS_VALUE_TYPE); String valueType = ValueType.extractType(datasetId, handleAsValueTypeFallback); String outputFormat = Constants.IMAGE_PNG; response.setContentType(outputFormat); createIoFactory(valueType).setParameters(parameters) .createHandler(outputFormat) .writeBinary(response.getOutputStream()); }
@RequestMapping(value = "/{datasetId}/data", produces = { Constants.APPLICATION_JSON }, method = RequestMethod.GET) public ModelAndView getSeriesData(HttpServletResponse response, @PathVariable String datasetId, @RequestHeader(value = Parameters.HttpHeader.ACCEPT_LANGUAGE, required = false) String locale, @RequestParam(required = false) MultiValueMap<String, String> query) throws Exception { IoParameters map = createParameters(datasetId, query, locale); LOGGER.debug("get data for item '{}' with query: {}", datasetId, map); checkAgainstTimespanRestriction(map.getTimespan()); checkForUnknownDatasetId(map.removeAllOf(Parameters.BBOX) .removeAllOf(Parameters.NEAR), datasetId); // RequestSimpleIoParameters parameters = RequestSimpleIoParameters.createForSingleSeries(seriesId, // map); String handleAsValueTypeFallback = map.getAsString(Parameters.HANDLE_AS_VALUE_TYPE); String valueType = ValueType.extractType(datasetId, handleAsValueTypeFallback); IoProcessChain< ? > ioChain = createIoFactory(valueType).setParameters(map) .createProcessChain(); DataCollection< ? > formattedDataCollection = ioChain.getProcessedData(); final Map<String, ? > processed = formattedDataCollection.getAllSeries(); return map.isExpanded() ? new ModelAndView().addObject(processed) : new ModelAndView().addObject(processed.get(datasetId)); }