/** * Constructor. Note: never pass in Hibernate objects that have been loaded * by a session in a different thread * * @param offering * Offering entity * @param datasets * metadtat of the related entities * @param defaultLanguage * the default language * @param i18NDAORepository * the i18n repository */ public OfferingCacheUpdateTask(OfferingEntity offering, Collection<DatasetEntity> datasets, Locale defaultLanguage, I18NDAORepository i18NDAORepository) { this.offering = offering; this.identifier = offering.getIdentifier(); this.datasets = datasets; this.defaultLanguage = defaultLanguage; this.i18NDAORepository = i18NDAORepository; }
@Override public String getLabelFrom(String locale) { StringBuilder sb = new StringBuilder(); sb.append(phenomenon.getLabelFrom(locale)) .append(" "); sb.append(procedure.getLabelFrom(locale)) .append(", "); sb.append(feature.getLabelFrom(locale)) .append(", "); return sb.append(offering.getLabelFrom(locale)) .toString(); }
OfferingEntity offering = getTOfferingForIdentifier(assignedOffering.getIdentifier(), session); if (offering == null) { offering = new OfferingEntity(); offering.setIdentifier(assignedOffering.getIdentifier()); if (assignedOffering.isSetName()) { offering.setName(assignedOffering.getFirstName().getValue()); } else { offering.setName("Offering for the procedure " + assignedOffering.getIdentifier()); offering.setDescription(assignedOffering.getDescription()); offering.setRelatedFeatures(new HashSet<>(relatedFeatures)); } else { offering.setRelatedFeatures(new HashSet<RelatedFeatureEntity>(0)); offering.setObservationTypes(new HashSet<>(observationTypes)); } else { offering.setObservationTypes(new HashSet<FormatEntity>(0)); offering.setFeatureTypes(new HashSet<>(featureOfInterestTypes)); } else { offering.setFeatureTypes(new HashSet<FormatEntity>(0));
public static OfferingEntity createOffering(String domainId, String name, ProxyServiceEntity service) { OfferingEntity offering = new OfferingEntity(); offering.setDomainId(domainId); offering.setName(name); offering.setService(service); return offering; }
private Set<String> getChildOfferings(OfferingEntity offering) { Set<String> childs = Sets.newTreeSet(); if (offering.hasChildren()) { for (OfferingEntity child : offering.getChildren()) { childs.add(child.getIdentifier()); childs.addAll(getChildOfferings(child)); } } return childs; }
private OfferingEntity getInstance(OfferingEntity offering) { return (OfferingEntity) this.session.createCriteria(getEntityClass()) .add(Restrictions.eq(OfferingEntity.PROPERTY_DOMAIN_ID, offering.getDomainId())) .add(Restrictions.eq(OfferingEntity.PROPERTY_SERVICE, offering.getService())) .uniqueResult(); }
public OfferingEntity updateOfferingMetadata(OfferingEntity offering, Data<?> observation, Session session) { if (offering.getSamplingTimeStart() == null || (offering.getSamplingTimeStart() != null && observation.getSamplingTimeStart() != null && offering.getSamplingTimeStart().after(observation.getSamplingTimeStart()))) { offering.setSamplingTimeStart(observation.getSamplingTimeStart()); if (offering.getSamplingTimeEnd() == null || (offering.getSamplingTimeEnd() != null && observation.getSamplingTimeEnd() != null && offering.getSamplingTimeEnd().before(observation.getSamplingTimeEnd()))) { offering.setSamplingTimeEnd(observation.getSamplingTimeEnd()); if (offering.getResultTimeStart() == null || (offering.getResultTimeStart() != null && observation.getResultTime() != null && offering.getResultTimeStart().after(observation.getResultTime()))) { offering.setResultTimeStart(observation.getResultTime()); if (offering.getResultTimeEnd() == null || (offering.getResultTimeEnd() != null && observation.getResultTime() != null && offering.getResultTimeEnd().before(observation.getResultTime()))) { offering.setResultTimeEnd(observation.getResultTime()); if (offering.getValidTimeStart() == null || (offering.getValidTimeStart() != null && observation.getValidTimeStart() != null && offering.getValidTimeStart().after(observation.getValidTimeStart()))) { offering.setValidTimeStart(observation.getValidTimeStart()); if (offering.getValidTimeEnd() == null || (offering.getValidTimeEnd() != null && observation.getValidTimeEnd() != null && offering.getValidTimeEnd().before(observation.getValidTimeEnd()))) { offering.setValidTimeEnd(observation.getValidTimeEnd());
getCache().setAllowedObservationTypeForOffering(identifier, toStringSet(offering.getObservationTypes())); if (offering.hasRelatedFeatures()) { getCache().setRelatedFeaturesForOffering(identifier, getRelatedFeatures(offering.getRelatedFeatures())); getCache().setAllowedFeatureOfInterestTypeForOffering(identifier, toStringSet(offering.getFeatureTypes())); getCache().setMinPhenomenonTimeForOffering(identifier, DateTimeHelper.makeDateTime(offering.getSamplingTimeStart())); getCache().setMaxPhenomenonTimeForOffering(identifier, DateTimeHelper.makeDateTime(offering.getSamplingTimeEnd())); getCache().setMinResultTimeForOffering(identifier, DateTimeHelper.makeDateTime(offering.getResultTimeStart())); getCache().setMaxResultTimeForOffering(identifier,DateTimeHelper.makeDateTime(offering.getResultTimeEnd()));
public void updateAfterObservationDeletion(org.n52.series.db.beans.OfferingEntity offering, DataEntity<?> observation, Session session) { SeriesObservationDAO seriesObservationDAO = new SeriesObservationDAO(daoFactory); if (offering.hasPhenomenonTimeStart() && offering.getSamplingTimeStart().equals(observation.getSamplingTimeStart())) { DataEntity<?> firstDataEntity = seriesObservationDAO.getFirstObservationFor(observation.getDataset(), session); if (firstDataEntity != null) { offering.setSamplingTimeStart(firstDataEntity.getSamplingTimeStart()); } } if (offering.hasPhenomenonTimeEnd() && offering.getSamplingTimeEnd().equals(observation.getSamplingTimeEnd())) { DataEntity<?> latestDataEntity = seriesObservationDAO.getLastObservationFor(observation.getDataset(), session); if (latestDataEntity != null) { offering.setSamplingTimeEnd(latestDataEntity.getSamplingTimeEnd()); } } }
protected void setUpTimeForOffering(OfferingEntity offering, SosObservationOffering sosOffering) { sosOffering.setPhenomenonTime(new TimePeriod(offering.getSamplingTimeStart(), offering.getSamplingTimeEnd())); sosOffering.setResultTime(new TimePeriod(offering.getResultTimeStart(), offering.getResultTimeEnd())); }
Collection<ProcedureEntity> procedures = getProceduresForOfferingEntity(offering, session); if (!procedures.isEmpty()) { Collection<FormatEntity> observationTypes = offering.getObservationTypes(); if (observationTypes != null && !observationTypes.isEmpty()) { if (offering.isSetGeometry()) { sosObservationOffering.setObservedArea(processObservedArea(JTSConverter .convert(offering.getGeometry()))); } else if (getCache().hasEnvelopeForOffering(offering.getIdentifier())) { sosObservationOffering.setObservedArea(getCache() .getEnvelopeForOffering(offering.getIdentifier())); .stream().filter(Objects::nonNull) .filter(provider -> provider.hasExtendedOfferingFor(offering .getIdentifier())) .map(provider -> provider .getOfferingExtensions(offering.getIdentifier())) .forEach(sosObservationOffering::addExtensions); LOGGER .error("No procedures are contained in the database for the offering {}! Please contact the admin of this SOS.", offering.getIdentifier());
private void updateSeries(DatasetEntity dataset, String observationType, Session session) { FormatEntity obsType = new FormatDAO().getFormatEntityObject(observationType, session); dataset.setObservationType(obsType); session.saveOrUpdate(dataset); // update hidden child observation constellations // TODO should hidden child observation constellations be restricted to // the parent observation type? Set<String> offerings = dataset.getOffering().getChildren().stream().map(o -> o.getIdentifier()).collect(Collectors.toSet()); if (CollectionHelper.isNotEmpty(offerings)) { Criteria c = session.createCriteria(getSeriesClass()) .setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY) .add(Restrictions.eq(DatasetEntity.PROPERTY_PHENOMENON, dataset.getObservableProperty())) .add(Restrictions.eq( DatasetEntity.PROPERTY_PROCEDURE, dataset.getProcedure())) .add(Restrictions.eq(DatasetEntity.HIDDEN_CHILD, true)); c.createCriteria( DatasetEntity.PROPERTY_OFFERING).add(Restrictions.in(OfferingEntity.IDENTIFIER, offerings)); LOGGER.debug("QUERY updateSeries(observationConstellation, observationType): {}", HibernateHelper.getSqlString(c)); List<DatasetEntity> hiddenChildObsConsts = c.list(); for (DatasetEntity hiddenChildObsConst : hiddenChildObsConsts) { hiddenChildObsConst.setObservationType(obsType); session.saveOrUpdate(hiddenChildObsConst); } } }
OfferingEntity hOfferingReferenceSeries = daoFactory.getOfferingDAO().getAndUpdateOrInsert( new SosOffering( hOffering.getIdentifier() + "_referencevalue", hOffering.getName() + "_referencevalue"), hRelatedFeatures, observationTypes, DatasetEntity hReferenceSeries = seriesDAO.getSeries(hProcedureReferenceSeries.getIdentifier(), hObservableProperty.getIdentifier(), hOfferingReferenceSeries.getIdentifier(), Collections.singleton(hFeature.getIdentifier()), session).get(0);
private ReferenceType getOfferingReference(Dataset entity, Map<String, ReferenceType> offerings){ String identifier = entity.getOffering().getIdentifier(); if (!offerings.containsKey(identifier)) { ReferenceType referenceType = new ReferenceType(identifier); if (entity.getOffering().isSetName()) { referenceType.setTitle(entity.getOffering().getName()); } offerings.put(identifier, referenceType); } return offerings.get(identifier); }
private OfferingOutput createCondensed(OfferingEntity entity, DbQuery parameters) { OfferingOutput result = new OfferingOutput(); result.setLabel(entity.getLabelFrom(parameters.getLocale())); result.setId(Long.toString(entity.getPkid())); result.setDomainId(entity.getDomainId()); checkForHref(result, parameters); return result; }
.getProceduresForOfferingEntity(offering, session); ReferencedEnvelope envelopeForOffering = getCache().getEnvelopeForOffering(offering .getIdentifier()); Set<String> featuresForoffering = getFOI4offering(offering.getIdentifier()); Collection<String> responseFormats = getResponseFormatRepository() .getSupportedResponseFormats(SosConstants.SOS, Sos1Constants.SERVICEVERSION); sosObservationOffering.setObservationTypes(getObservationTypes(offering.getIdentifier())); if (offering.isSetGeometry()) { sosObservationOffering.setObservedArea(processObservedArea(JTSConverter.convert(offering .getGeometry()))); } else if (getCache().hasEnvelopeForOffering(offering.getIdentifier())) { sosObservationOffering.setObservedArea(getCache().getEnvelopeForOffering(offering .getIdentifier())); .getObservablePropertiesForOffering(offering.getIdentifier())); Set<String> compositePhenomenonsForOffering = getCache().getCompositePhenomenonsForOffering(offering .getIdentifier()); sosObservationOffering.setCompositePhenomena(compositePhenomenonsForOffering); sosObservationOffering.setFeatureOfInterest(getFOI4offering(offering.getIdentifier())); .getObservationTypesForOffering(offering.getIdentifier())); sosObservationOffering.setResultModels(resultModels);
@Override public void execute() { LOGGER.debug("Executing ObservationTimeCacheUpdate"); startStopwatch(); try { // TODD Use TimerPeriod.expand from OfferingTimes List<OfferingEntity> offerings = new OfferingDao(getSession()).getAllInstances(new DbQuery(IoParameters.createDefaults())); TimePeriod phenomenonTime = new TimePeriod(); TimePeriod resultTime = new TimePeriod(); for (OfferingEntity offering : offerings) { phenomenonTime.extendToContain(new TimePeriod(offering.getPhenomenonTimeStart(), offering.getPhenomenonTimeEnd())); resultTime.extendToContain(new TimePeriod(offering.getResultTimeStart(), offering.getResultTimeEnd())); } getCache().setMinPhenomenonTime(phenomenonTime.getStart()); getCache().setMaxPhenomenonTime(phenomenonTime.getEnd()); getCache().setMinResultTime(resultTime.getStart()); getCache().setMaxResultTime(resultTime.getEnd()); } catch (HibernateException | DataAccessException dae) { getErrors().add(new NoApplicableCodeException().causedBy(dae) .withMessage("Error while updating observation time cache!")); } LOGGER.debug("Finished executing ObservationTimeCacheUpdate ({})", getStopwatchResult()); }
name = new MultilingualString(); description = new MultilingualString(); if (offering.isSetName()) { final Locale locale = defaultLanguage; name.addLocalization(locale, offering.getName()); } else { String offeringName = identifier; if (offering.isSetDescription()) { final Locale locale = defaultLanguage; description.addLocalization(locale, offering.getDescription());
public OfferingEntity putOffering(OfferingEntity offering) { offerings.put(offering.getDomainId(), offering); return offering; }
public void updateParentOfferings(Set<String> parentOfferings, OfferingEntity hOffering, Session session) { for (String identifier : parentOfferings) { OfferingEntity offering = getOfferingForIdentifier(identifier, session); if (!offering.getChildren().contains(hOffering)) { offering.addChild(hOffering); session.saveOrUpdate(offering); session.flush(); session.refresh(offering); } } }