@Override public UnitEntity getUom(DatasetEntity seriesEntity) { // TODO implement return EntityBuilder.createUnit("unit", null, (ProxyServiceEntity) seriesEntity.getService()); }
@SuppressWarnings("unchecked") private T getInstance(T dataset) { return (T) getDefaultCriteria(ProxyDbQuery.createDefaults()) .add(Restrictions.eq(DatasetEntity.PROPERTY_VALUE_TYPE, dataset.getValueType())) .add(Restrictions.eq(DatasetEntity.PROPERTY_CATEGORY, dataset.getCategory())) .add(Restrictions.eq(DatasetEntity.PROPERTY_FEATURE, dataset.getFeature())) .add(Restrictions.eq(DatasetEntity.PROPERTY_PROCEDURE, dataset.getProcedure())) .add(Restrictions.eq(DatasetEntity.PROPERTY_PHENOMENON, dataset.getPhenomenon())) .add(Restrictions.eq(DatasetEntity.PROPERTY_OFFERING, dataset.getOffering())) .add(Restrictions.eq(DatasetEntity.PROPERTY_SERVICE, dataset.getService())) .uniqueResult(); }
@Override public String toString() { StringBuilder sb = new StringBuilder(); return sb.append(getClass().getSimpleName()) .append(" [") .append(" id: ") .append(getId()) .append(" , category: ") .append(getCategory()) .append(" , phenomenon: ") .append(getPhenomenon()) .append(" , procedure: ") .append(getProcedure()) .append(" , offering: ") .append(getOffering()) .append(" , feature: ") .append(getFeature()) .append(" , service: ") .append(getService()) .append(" ]") .toString(); }
private DataEntity<?> createObservationBounds(DatasetEntity entity, String order) { String e = String.format("Datastreams(%s)/Observations?$orderby=phenomenonTime%%20%s&$top=1", entity.getDomainId(), order); Observations observations = (Observations) doGetRequest(entity.getService().getUrl(), e, Observations.class); if (observations.getValue().size() == 1) { return createObservation(observations.getValue().get(0)); } return null; }
dataEntity.setTimestart(timestamp); dataEntity.setTimeend(timestamp); ProxyServiceEntity service = (ProxyServiceEntity) seriesEntity.getService(); Optional<Set<DataEntity<?>>> values = Optional.ofNullable(obsValue) .map(ObservationValue::getValue)
@Override public UnitEntity getUom(DatasetEntity seriesEntity) { GetObservationResponse response = getObservation(seriesEntity, createFirstTimefilter()); return response.getObservationCollection().toStream() .findFirst().map(o -> o.getValue().getValue().getUnit()) .map(unit -> EntityBuilder.createUnit(unit, null, (ProxyServiceEntity) seriesEntity.getService())) .orElse(null); }
@Override public UnitEntity getUom(DatasetEntity seriesEntity) { GetDataAvailabilityResponse availabilityResponse = getDataAvailability(seriesEntity); if (availabilityResponse.getDataAvailabilities().size() == 1) { DateTime start = availabilityResponse.getDataAvailabilities().get(0).getPhenomenonTime().getStart(); GetObservationResponse response = createObservationResponse(seriesEntity, createTimeFilter(start)); return response.getObservationCollection().toStream() .findFirst() .map(OmObservation::getValue) .map(ObservationValue::getValue) .map(v -> v.getUnit()) .map(unit -> EntityBuilder.createUnit(unit, null, (ProxyServiceEntity) seriesEntity.getService())) .orElse(null); } return null; }
@Override public UnitEntity getUom(DatasetEntity seriesEntity) { GetObservationResponse observationResponse = getObservation(seriesEntity, null, OM_2_MIMETYPE); List<OmObservation> omColl = observationResponse.getObservationCollection().toStream().collect(toList()); if (omColl.size() == 1) { OmObservation observation = omColl.get(0); ObservationValue<? extends Value<?>> observationValue = observation.getValue(); if (observationValue.getValue() instanceof SweDataArrayValue) { SweDataArray dataArray = ((SweDataArrayValue) observationValue.getValue()).getValue(); SweAbstractDataComponent elementType = dataArray.getElementType(); if (elementType instanceof SweDataRecord) { SweDataRecord sweDataRecord = (SweDataRecord) elementType; List<SweField> fields = sweDataRecord.getFields(); if (fields.size() == 2) { return createUnitEntity(fields.get(1), (ProxyServiceEntity) seriesEntity.getService()); } } } } return null; }
private List<DataEntity<?>> createObservations(DatasetEntity seriesEntity, DateTime start, DateTime end) { String entity = String.format("Datastreams(%s)/Observations?$filter=" + "phenomenonTime%%20gt%%20'%s'" + "%%20and%%20" + "phenomenonTime%%20lt%%20'%s'", seriesEntity.getDomainId(), start.toString(formatter), end.toString(formatter)); Observations observations = (Observations) doGetRequest(seriesEntity.getService().getUrl(), entity, Observations.class); List<DataEntity<?>> list = new LinkedList<>(); addObservationsToList(observations, list); while (observations.getNextLink() != null) { observations = (Observations) doGetRequest(observations.getNextLink(), Observations.class); addObservationsToList(observations, list); } return list; }
@Override @SuppressWarnings("rawtypes") protected DatasetOutput createExpanded(DatasetEntity series, DbQuery query, Session session) throws DataAccessException { if (series.getUnit() == null || Strings.isNullOrEmpty(series.getUnit().getName())) { Transaction transaction = null; try { transaction = session.beginTransaction(); ProxyServiceEntity service = (ProxyServiceEntity) series.getService(); String connectorName = service.getConnector(); AbstractConnector connector = connectorMap.get(connectorName); UnitEntity unit = connector.getUom(series); if (unit == null) { // create empty unit unit = EntityBuilder.createUnit("", null, service); } series.setUnit(unit); session.save(unit); session.save(series); session.flush(); transaction.commit(); } catch (DataAccessException | HibernateException ex) { if (transaction != null) { transaction.rollback(); } } } return super.createExpanded(series, query, session); }
protected GetObservationResponse getObservation(DatasetEntity seriesEntity, List<TemporalFilter> temporalFilter, SpatialFilter spatialFilter, String responseFormat) { GetObservationRequest request = new GetObservationRequest(SosConstants.SOS, Sos2Constants.SERVICEVERSION); request.addProcedure(seriesEntity.getProcedure().getDomainId()); request.addOffering(seriesEntity.getOffering().getDomainId()); request.addObservedProperty(seriesEntity.getPhenomenon().getDomainId()); request.addFeatureIdentifier(seriesEntity.getFeature().getDomainId()); Optional.ofNullable(temporalFilter).ifPresent(request::setTemporalFilters); Optional.ofNullable(spatialFilter).ifPresent(request::setSpatialFilter); Optional.ofNullable(responseFormat).ifPresent(request::setResponseFormat); return (GetObservationResponse) getSosResponseFor(request, Sos2Constants.NS_SOS_20, seriesEntity.getService().getUrl()); } }
protected GetDataAvailabilityResponse getDataAvailability(DatasetEntity seriesEntity) { return getDataAvailability(seriesEntity.getProcedure().getDomainId(), seriesEntity.getOffering().getDomainId(), seriesEntity.getPhenomenon().getDomainId(), seriesEntity.getFeature().getDomainId(), seriesEntity.getService().getUrl()); }
private DatasetEntity insertDataset(DatasetEntity dataset, CategoryEntity category, ProcedureEntity procedure, OfferingEntity offering, FeatureEntity feature, PhenomenonEntity phenomenon, Session session) { dataset.setCategory(category); dataset.setProcedure(procedure); dataset.setOffering(offering); dataset.setFeature(feature); dataset.setPhenomenon(phenomenon); if (dataset.getUnit() != null) { dataset.getUnit().setService(dataset.getService()); } return new ProxyDatasetDao<>(session).getOrInsertInstance(dataset); }
@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); } }
protected DatasetOutput<AbstractValue<?>> createExpanded(DatasetEntity dataset, DbQuery query, Session session) throws DataAccessException { try { IoParameters params = query.getParameters(); DatasetOutput result = createCondensed(dataset, query, session); DatasetParameters datasetParams = createDatasetParameters(dataset, query.withoutFieldsFilter(), session); datasetParams.setPlatform(getCondensedPlatform(dataset, query, session)); if (dataset.getService() == null) { dataset.setService(getServiceEntity()); } DataRepository dataRepository = dataRepositoryFactory.create(dataset.getValueType()); AbstractValue firstValue = dataRepository.getFirstValue(dataset, session, query); AbstractValue lastValue = dataRepository.getLastValue(dataset, session, query); List<ReferenceValueOutput> refValues = dataRepository.createReferenceValueOutputs(dataset, query); lastValue = isReferenceSeries(dataset) && isCongruentValues(firstValue, lastValue) // first == last to have a valid interval ? firstValue : lastValue; result.setValue(DatasetOutput.REFERENCE_VALUES, refValues, params, result::setReferenceValues); result.setValue(DatasetOutput.DATASET_PARAMETERS, datasetParams, params, result::setDatasetParameters); result.setValue(DatasetOutput.FIRST_VALUE, firstValue, params, result::setFirstValue); result.setValue(DatasetOutput.LAST_VALUE, lastValue, params, result::setLastValue); return result; } catch (DatasetFactoryException ex) { throwNewCreateFactoryException(ex); return null; } }