Examples with RelatedFeatureEntity org.n52.series.db.beans.RelatedFeatureEntity used on opensource projects

Example 1 with RelatedFeatureEntity

use of org.n52.series.db.beans.RelatedFeatureEntity in project SOS by 52North.

the class RelatedFeaturesCacheUpdate method execute.

@Override
public void execute() {
    LOGGER.debug("Executing RelatedFeaturesCacheUpdate");
    startStopwatch();
    try {
        for (RelatedFeatureEntity relatedFeature : new RelatedFeatureDao(getSession()).getAllInstances(new DbQuery(IoParameters.createDefaults()))) {
            String identifier = relatedFeature.getFeature().getIdentifier();
            for (OfferingEntity offering : relatedFeature.getOfferings()) {
                getCache().addRelatedFeatureForOffering(offering.getIdentifier(), identifier);
            }
            getCache().addRoleForRelatedFeature(identifier, relatedFeature.getRole());
        }
    } catch (HibernateException | DataAccessException dae) {
        getErrors().add(new NoApplicableCodeException().causedBy(dae).withMessage("Error while updating related feature cache!"));
    }
    LOGGER.debug("Finished executing RelatedFeaturesCacheUpdate ({})", getStopwatchResult());
}

Example 2 with RelatedFeatureEntity

use of org.n52.series.db.beans.RelatedFeatureEntity in project SOS by 52North.

the class RelatedFeatureDAO method getOrInsertRelatedFeature.

/**
 * Insert and get related feature objects.
 *
 * @param feature
 *            Related feature
 * @param role
 *            Related feature role objects
 * @param session
 *            Hibernate session
 * @return Related feature objects
 * @throws OwsExceptionReport
 *             If an error occurs
 */
public List<RelatedFeatureEntity> getOrInsertRelatedFeature(final AbstractFeature feature, final String role, final Session session) throws OwsExceptionReport {
    // TODO: create featureOfInterest and link to relatedFeature
    List<RelatedFeatureEntity> relFeats = getRelatedFeatures(feature.getIdentifierCodeWithAuthority().getValue(), session);
    if (relFeats == null) {
        relFeats = new LinkedList<>();
    }
    if (relFeats.isEmpty() && role != null && !role.isEmpty()) {
        final RelatedFeatureEntity relFeat = new RelatedFeatureEntity();
        String identifier = feature.getIdentifierCodeWithAuthority().getValue();
        String url = null;
        if (feature instanceof AbstractSamplingFeature) {
            identifier = daoFactory.getFeatureQueryHandler().insertFeature((AbstractSamplingFeature) feature, session);
            url = ((AbstractSamplingFeature) feature).getUrl();
        }
        relFeat.setFeature(daoFactory.getFeatureOfInterestDAO().getOrInsert(identifier, url, session));
        relFeat.setRole(role);
        session.save(relFeat);
        session.flush();
        relFeats.add(relFeat);
    }
    return relFeats;
}

Example 3 with RelatedFeatureEntity

use of org.n52.series.db.beans.RelatedFeatureEntity in project SOS by 52North.

the class OfferingDAO method getAndUpdateOrInsert.

/**
 * Insert or update and get offering
 *
 * @param assignedOffering
 *            SosOffering to insert, update or get
 * @param relatedFeatures
 *            Related feature objects
 * @param observationTypes
 *            Allowed observation type objects
 * @param featureOfInterestTypes
 *            Allowed featureOfInterest type objects
 * @param session
 *            Hibernate session
 * @return Offering object
 */
public OfferingEntity getAndUpdateOrInsert(SosOffering assignedOffering, Collection<RelatedFeatureEntity> relatedFeatures, Collection<FormatEntity> observationTypes, Collection<FormatEntity> featureOfInterestTypes, Session session) {
    OfferingEntity offering = getTOfferingForIdentifier(assignedOffering.getIdentifier(), session);
    if (offering == null) {
        offering = new OfferingEntity();
        offering.setIdentifier(assignedOffering.getIdentifier(), getDaoFactory().isStaSupportsUrls());
        if (assignedOffering.isSetName()) {
            offering.setName(assignedOffering.getFirstName().getValue());
        } else {
            offering.setName("Offering for the procedure " + assignedOffering.getIdentifier());
        }
        if (assignedOffering.isSetDescription()) {
            offering.setDescription(assignedOffering.getDescription());
        }
    }
    if (!relatedFeatures.isEmpty()) {
        offering.setRelatedFeatures(new HashSet<>(relatedFeatures));
    } else {
        offering.setRelatedFeatures(new HashSet<RelatedFeatureEntity>(0));
    }
    if (!observationTypes.isEmpty()) {
        offering.setObservationTypes(new HashSet<>(observationTypes));
    } else {
        offering.setObservationTypes(new HashSet<FormatEntity>(0));
    }
    if (!featureOfInterestTypes.isEmpty()) {
        offering.setFeatureTypes(new HashSet<>(featureOfInterestTypes));
    } else {
        offering.setFeatureTypes(new HashSet<FormatEntity>(0));
    }
    session.saveOrUpdate(offering);
    session.flush();
    session.refresh(offering);
    return offering;
}

Example 4 with RelatedFeatureEntity

use of org.n52.series.db.beans.RelatedFeatureEntity in project SOS by 52North.

the class InsertSensorHandler method addStaticReferenceValues.

private void addStaticReferenceValues(InsertSensorRequest request, Session session, FormatEntity procedureDescriptionFormat, ProcedureEntity hProcedure, List<FormatEntity> observationTypes, List<FormatEntity> featureOfInterestTypes, List<RelatedFeatureEntity> hRelatedFeatures, OfferingEntity hOffering, PhenomenonEntity hObservableProperty, AbstractSeriesDAO seriesDAO) throws OwsExceptionReport {
    AbstractFeature sosFeatureOfInterest = request.getProcedureDescription().getFeaturesOfInterestMap().entrySet().iterator().next().getValue();
    AbstractFeatureEntity<?> hFeature = getDaoFactory().getFeatureDAO().insertFeature(sosFeatureOfInterest, session);
    for (SmlCapability referenceValue : ((AbstractSensorML) request.getProcedureDescription().getProcedureDescription()).findCapabilities(REFERENCE_VALUES_PREDICATE).get().getCapabilities()) {
        if (!(referenceValue.getAbstractDataComponent() instanceof SweQuantity)) {
            throw new NoApplicableCodeException().withMessage("ReferenceValue of Type '%s' is not supported -> Aborting InsertSensor Operation!", referenceValue.getAbstractDataComponent().getDataComponentType());
        }
        SweQuantity referenceValueValue = (SweQuantity) referenceValue.getAbstractDataComponent();
        String identifier = hProcedure.getIdentifier() + REFERENCE_VALUE;
        SosProcedureDescription<?> procedureReferenceSeries = new SosProcedureDescriptionUnknownType(identifier, procedureDescriptionFormat.getFormat(), "");
        procedureReferenceSeries.setReference(true);
        procedureReferenceSeries.setName(new CodeType(referenceValue.getName()));
        ProcedureEntity hProcedureReferenceSeries = getDaoFactory().getProcedureDAO().getOrInsertProcedure(identifier, procedureDescriptionFormat, procedureReferenceSeries, false, session);
        OfferingEntity hOfferingReferenceSeries = getDaoFactory().getOfferingDAO().getAndUpdateOrInsert(new SosOffering(hOffering.getIdentifier() + REFERENCE_VALUE, hOffering.getName() + REFERENCE_VALUE), hRelatedFeatures, observationTypes, featureOfInterestTypes, session);
        TimeInstant time = new TimeInstant(new DateTime(0));
        SingleObservationValue<BigDecimal> sosValue = new SingleObservationValue<>(new QuantityValue(referenceValueValue.getValue(), referenceValueValue.getUom()));
        OmObservation sosObservation = new OmObservation();
        sosValue.setPhenomenonTime(time);
        sosObservation.setResultTime(time);
        sosObservation.setValue(sosValue);
        sosObservation.setObservationConstellation(new OmObservationConstellation(procedureReferenceSeries, new OmObservableProperty(hObservableProperty.getIdentifier()), sosFeatureOfInterest));
        DatasetEntity hObservationConstellationReferenceSeries = new DatasetEntity();
        hObservationConstellationReferenceSeries.setObservableProperty(hObservableProperty);
        hObservationConstellationReferenceSeries.setOffering(hOfferingReferenceSeries);
        hObservationConstellationReferenceSeries.setProcedure(hProcedureReferenceSeries);
        Map<String, CodespaceEntity> codespaceCache = CollectionHelper.synchronizedMap();
        Map<UoM, UnitEntity> unitCache = CollectionHelper.synchronizedMap();
        Map<String, FormatEntity> formatCache = CollectionHelper.synchronizedMap();
        ObservationPersister persister = new ObservationPersister(getDaoFactory(), getDaoFactory().getObservationDAO(), sosObservation, hObservationConstellationReferenceSeries, hFeature, codespaceCache, unitCache, formatCache, Collections.singleton(hOfferingReferenceSeries), session);
        DataEntity<?> observation = sosValue.getValue().accept(persister);
        DatasetEntity hReferenceSeries = seriesDAO.getSeries(hProcedureReferenceSeries.getIdentifier(), hObservableProperty.getIdentifier(), hOfferingReferenceSeries.getIdentifier(), Collections.singleton(hFeature.getIdentifier()), session).get(0);
        hReferenceSeries.setPublished(false);
        session.update(hReferenceSeries);
        ObservationContext ctxReferenced = new ObservationContext();
        ctxReferenced.setPhenomenon(hObservableProperty);
        ctxReferenced.setFeatureOfInterest(hFeature);
        ctxReferenced.setProcedure(hProcedure);
        ctxReferenced.setOffering(hOffering);
        ctxReferenced.setPublish(false);
        DatasetEntity hSeries = seriesDAO.getOrInsertSeries(ctxReferenced, observation, session);
        if (hSeries.getValueType().equals(ValueType.quantity)) {
            hSeries.setReferenceValues(Lists.newArrayList(hReferenceSeries));
        }
        session.update(hSeries);
    }
}

Example 5 with RelatedFeatureEntity

use of org.n52.series.db.beans.RelatedFeatureEntity in project SOS by 52North.

the class InsertSensorHandler method insertSensor.

@Override
public synchronized InsertSensorResponse insertSensor(final InsertSensorRequest request) throws OwsExceptionReport {
    final InsertSensorResponse response = new InsertSensorResponse();
    response.setService(request.getService());
    response.setVersion(request.getVersion());
    final String assignedProcedureID = request.getAssignedProcedureIdentifier();
    // we use only the first offering for the response because swes 2.0
    // specifies only one single element
    final SosOffering firstAssignedOffering = request.getFirstAssignedOffering();
    Session session = null;
    Transaction transaction = null;
    try {
        session = getHibernateSessionHolder().getSession();
        transaction = session.beginTransaction();
        FormatDAO formatDAO = new FormatDAO();
        final FormatEntity procedureDescriptionFormat = formatDAO.getOrInsertFormatEntity(request.getProcedureDescriptionFormat(), session);
        if (procedureDescriptionFormat != null) {
            final ProcedureEntity hProcedure = new ProcedureDAO(getDaoFactory()).getOrInsertProcedure(assignedProcedureID, procedureDescriptionFormat, request.getProcedureDescription(), request.isType(), session);
            // TODO: set correct validTime,
            new ProcedureHistoryDAO(getDaoFactory()).insert(hProcedure, procedureDescriptionFormat, getSensorDescriptionFromProcedureDescription(request.getProcedureDescription()), new DateTime(DateTimeZone.UTC), session);
            if (!request.isType()) {
                final List<FormatEntity> observationTypes = formatDAO.getOrInsertFormatEntitys(request.getMetadata().getObservationTypes(), session);
                final List<FormatEntity> featureOfInterestTypes = formatDAO.getOrInsertFormatEntitys(request.getMetadata().getFeatureOfInterestTypes(), session);
                if (observationTypes != null && featureOfInterestTypes != null) {
                    final List<PhenomenonEntity> hObservableProperties = getOrInsertNewObservableProperties(request.getObservableProperty(), request.getProcedureDescription(), session);
                    Map<String, UnitEntity> hUnits = getOrInsertNewUnits(hObservableProperties, request.getProcedureDescription(), session);
                    final AbstractSeriesDAO seriesDAO = getDaoFactory().getSeriesDAO();
                    final OfferingDAO offeringDAO = getDaoFactory().getOfferingDAO();
                    Set<String> allParentOfferings = getAllParentOfferings(hProcedure);
                    Set<String> parentOfferings = getParentOfferings(hProcedure);
                    for (final SosOffering assignedOffering : request.getAssignedOfferings()) {
                        final List<RelatedFeatureEntity> hRelatedFeatures = new LinkedList<RelatedFeatureEntity>();
                        if (request.getRelatedFeatures() != null && !request.getRelatedFeatures().isEmpty()) {
                            final RelatedFeatureDAO relatedFeatureDAO = getDaoFactory().getRelatedFeatureDAO();
                            for (final SwesFeatureRelationship relatedFeature : request.getRelatedFeatures()) {
                                hRelatedFeatures.addAll(relatedFeatureDAO.getOrInsertRelatedFeature(relatedFeature.getFeature(), relatedFeature.getRole(), session));
                            }
                        }
                        final OfferingEntity hOffering = offeringDAO.getAndUpdateOrInsert(new SosOffering(assignedOffering.getIdentifier(), assignedOffering.getOfferingName()), hRelatedFeatures, observationTypes, featureOfInterestTypes, session);
                        // is a child/component
                        if (!parentOfferings.isEmpty() && !allParentOfferings.isEmpty() && hProcedure.hasParents() && !allParentOfferings.contains(assignedOffering.getIdentifier()) && !parentOfferings.contains(assignedOffering.getIdentifier())) {
                            offeringDAO.updateParentOfferings(parentOfferings, hOffering, session);
                        }
                        for (final PhenomenonEntity hObservableProperty : hObservableProperties) {
                            CategoryEntity hCategory = getCategory(hObservableProperty, request, session);
                            ObservationContext ctx = new ObservationContext().setCategory(hCategory).setOffering(hOffering).setPhenomenon(hObservableProperty).setProcedure(hProcedure).setPublish(false).setHiddenChild(!assignedOffering.isParentOffering());
                            checkForMobileInsituFlags(ctx, request.getProcedureDescription().getProcedureDescription());
                            if (hUnits.containsKey(hObservableProperty.getIdentifier())) {
                                ctx.setUnit(hUnits.get(hObservableProperty.getIdentifier()));
                            }
                            if (request.getProcedureDescription().isSetFeaturesOfInterestMap()) {
                                boolean inserted = false;
                                for (AbstractFeature feature : request.getProcedureDescription().getFeaturesOfInterestMap().values()) {
                                    if (feature instanceof FeatureWithGeometry && ((FeatureWithGeometry) feature).isSetGeometry()) {
                                        ctx.setFeatureOfInterest(getDaoFactory().getFeatureOfInterestDAO().checkOrInsert(feature, session));
                                        inserted = true;
                                        seriesDAO.getOrInsert(ctx, session);
                                    }
                                }
                                if (!inserted) {
                                    seriesDAO.getOrInsert(ctx, session);
                                }
                            } else {
                                seriesDAO.getOrInsert(ctx, session);
                            }
                            if (checkPreconditionsOfStaticReferenceValues(request)) {
                                addStaticReferenceValues(request, session, procedureDescriptionFormat, hProcedure, observationTypes, featureOfInterestTypes, hRelatedFeatures, hOffering, hObservableProperty, seriesDAO);
                            }
                        }
                    }
                // TODO: parent and child procedures
                } else {
                    throw new NoApplicableCodeException().withMessage("Error while inserting InsertSensor into database!");
                }
            }
            response.setAssignedProcedure(assignedProcedureID);
            response.setAssignedOffering(firstAssignedOffering.getIdentifier());
        } else {
            throw new InvalidParameterValueException(Sos2Constants.InsertSensorParams.procedureDescriptionFormat, request.getProcedureDescriptionFormat());
        }
        session.flush();
        transaction.commit();
    } catch (final HibernateException he) {
        if (transaction != null) {
            transaction.rollback();
        }
        throw new NoApplicableCodeException().causedBy(he).withMessage("Error while inserting sensor data into database!");
    } finally {
        getHibernateSessionHolder().returnSession(session);
    }
    return response;
}