Esempio n. 1
0
 /**
  * Check if result times should be added
  *
  * @param request GetDataAvailability request
  * @return <code>true</code>, if result times should be added
  */
 private boolean isIncludeResultTime(GetDataAvailabilityRequest request) {
   if (request.isSetExtensions()) {
     return request.getExtensions().isBooleanExtensionSet(INCLUDE_RESULT_TIMES)
         || hasPhenomenonTimeFilter(request.getExtensions());
   }
   return false;
 }
Esempio n. 2
0
 /**
  * GetDataAvailability processing is series mapping is supported.
  *
  * @param request GetDataAvailability request
  * @param session Hibernate session
  * @return List of valid data availability information
  * @throws OwsExceptionReport If an error occurs
  */
 private List<?> querySeriesDataAvailabilities(GetDataAvailabilityRequest request, Session session)
     throws OwsExceptionReport {
   List<DataAvailability> dataAvailabilityValues = Lists.newLinkedList();
   Map<String, ReferenceType> procedures = new HashMap<String, ReferenceType>();
   Map<String, ReferenceType> observableProperties = new HashMap<String, ReferenceType>();
   Map<String, ReferenceType> featuresOfInterest = new HashMap<String, ReferenceType>();
   AbstractSeriesObservationDAO seriesObservationDAO = getSeriesObservationDAO();
   SeriesMinMaxTransformer seriesMinMaxTransformer = new SeriesMinMaxTransformer();
   boolean supportsNamedQuery =
       HibernateHelper.isNamedQuerySupported(SQL_QUERY_GET_DATA_AVAILABILITY_FOR_SERIES, session);
   for (final Series series :
       DaoFactory.getInstance()
           .getSeriesDAO()
           .getSeries(
               request.getProcedures(),
               request.getObservedProperties(),
               request.getFeaturesOfInterest(),
               session)) {
     TimePeriod timePeriod = null;
     if (!request.isSetOfferings()) {
       // get time information from series object
       if (series.isSetFirstLastTime()) {
         timePeriod = new TimePeriod(series.getFirstTimeStamp(), series.getLastTimeStamp());
       }
       // get time information from a named query
       else if (timePeriod == null && supportsNamedQuery) {
         timePeriod =
             getTimePeriodFromNamedQuery(series.getSeriesId(), seriesMinMaxTransformer, session);
       }
     }
     // get time information from SeriesGetDataAvailability mapping if
     // supported
     if (timePeriod == null) {
       SeriesObservationTimeDAO seriesObservationTimeDAO =
           (SeriesObservationTimeDAO) DaoFactory.getInstance().getObservationTimeDAO();
       timePeriod =
           getTimePeriodFromSeriesGetDataAvailability(
               seriesObservationTimeDAO, series, request, seriesMinMaxTransformer, session);
     }
     // create DataAvailabilities
     if (timePeriod != null && !timePeriod.isEmpty()) {
       DataAvailability dataAvailability =
           new DataAvailability(
               getProcedureReference(series, procedures),
               getObservedPropertyReference(series, observableProperties),
               getFeatureOfInterestReference(series, featuresOfInterest, session),
               timePeriod);
       if (isShowCount(request)) {
         dataAvailability.setCount(getCountFor(series, request, session));
       }
       if (isIncludeResultTime(request)) {
         dataAvailability.setResultTimes(
             getResultTimesFromSeriesObservation(seriesObservationDAO, series, request, session));
       }
       dataAvailabilityValues.add(dataAvailability);
     }
   }
   return dataAvailabilityValues;
 }
Esempio n. 3
0
 /**
  * Get count of available observation for this time series
  *
  * @param series Time series
  * @param request GetDataAvailability request
  * @param session Hibernate session
  * @return Count of available observations
  */
 private Long getCountFor(Series series, GetDataAvailabilityRequest request, Session session) {
   Criteria criteria =
       session
           .createCriteria(SeriesObservationInfo.class)
           .add(Restrictions.eq(AbstractObservation.DELETED, false));
   criteria.add(Restrictions.eq(SeriesObservationInfo.SERIES, series));
   if (request.isSetOfferings()) {
     criteria
         .createCriteria(SeriesObservationTime.OFFERINGS)
         .add(Restrictions.in(Offering.IDENTIFIER, request.getOfferings()));
   }
   criteria.setProjection(Projections.rowCount());
   return (Long) criteria.uniqueResult();
 }
Esempio n. 4
0
 /**
  * Get the result times for the timeseries
  *
  * @param seriesObservationDAO DAO
  * @param series time series
  * @param request GetDataAvailability request
  * @param session Hibernate session
  * @return List of result times
  * @throws OwsExceptionReport if the requested temporal filter is not supported
  */
 private List<TimeInstant> getResultTimesFromSeriesObservation(
     AbstractSeriesObservationDAO seriesObservationDAO,
     Series series,
     GetDataAvailabilityRequest request,
     Session session)
     throws OwsExceptionReport {
   Criterion filter = null;
   if (hasPhenomenonTimeFilter(request.getExtensions())) {
     filter = TemporalRestrictions.filter(getPhenomenonTimeFilter(request.getExtensions()));
   }
   List<Date> dateTimes =
       seriesObservationDAO.getResultTimesForSeriesObservation(
           series, request.getOfferings(), filter, session);
   List<TimeInstant> resultTimes = Lists.newArrayList();
   for (Date date : dateTimes) {
     resultTimes.add(new TimeInstant(date));
   }
   return resultTimes;
 }
Esempio n. 5
0
 private boolean checkForNamedQueries(GetDataAvailabilityRequest req, Session session) {
   final boolean features = req.isSetFeaturesOfInterest();
   final boolean observableProperties = req.isSetObservedProperties();
   final boolean procedures = req.isSetProcedures();
   // all
   if (features && observableProperties && procedures) {
     return HibernateHelper.isNamedQuerySupported(
         SQL_QUERY_GET_DATA_AVAILABILITY_FOR_FEATURES_PROCEDURES_OBSERVED_PROPERTIES, session);
   }
   // observableProperties and procedures
   else if (!features && observableProperties && procedures) {
     return HibernateHelper.isNamedQuerySupported(
         SQL_QUERY_GET_DATA_AVAILABILITY_FOR_PROCEDURES_OBSERVED_PROPERTIES, session);
   }
   // only observableProperties
   else if (!features && observableProperties && !procedures) {
     return HibernateHelper.isNamedQuerySupported(
         SQL_QUERY_GET_DATA_AVAILABILITY_FOR_OBSERVED_PROPERTIES, session);
   }
   // only procedures
   else if (!features && !observableProperties && procedures) {
     return HibernateHelper.isNamedQuerySupported(
         SQL_QUERY_GET_DATA_AVAILABILITY_FOR_PROCEDURES, session);
   }
   // features and observableProperties
   else if (features && observableProperties && !procedures) {
     return HibernateHelper.isNamedQuerySupported(
         SQL_QUERY_GET_DATA_AVAILABILITY_FOR_FEATURES_OBSERVED_PROPERTIES, session);
   }
   // features and procedures
   else if (features && !observableProperties && procedures) {
     return HibernateHelper.isNamedQuerySupported(
         SQL_QUERY_GET_DATA_AVAILABILITY_FOR_FEATURES_PROCEDURES, session);
   }
   // only features
   else if (features && !observableProperties && procedures) {
     return HibernateHelper.isNamedQuerySupported(
         SQL_QUERY_GET_DATA_AVAILABILITY_FOR_FEATURES, session);
   }
   return false;
 }
Esempio n. 6
0
 /**
  * Get time information from SeriesGetDataAvailability mapping
  *
  * @param seriesGetDataAvailabilityDAO Series GetDataAvailability DAO class
  * @param series Series to get information for
  * @param request
  * @param seriesMinMaxTransformer Hibernate result transformator for min/max time value
  * @param session Hibernate Session
  * @return Time period
  */
 private TimePeriod getTimePeriodFromSeriesGetDataAvailability(
     SeriesObservationTimeDAO seriesGetDataAvailabilityDAO,
     Series series,
     GetDataAvailabilityRequest request,
     SeriesMinMaxTransformer seriesMinMaxTransformer,
     Session session) {
   Criteria criteria =
       seriesGetDataAvailabilityDAO.getMinMaxTimeCriteriaForSeriesGetDataAvailabilityDAO(
           series, request.getOfferings(), session);
   criteria.setResultTransformer(seriesMinMaxTransformer);
   LOGGER.debug(
       "QUERY getTimePeriodFromSeriesObservation(series): {}",
       HibernateHelper.getSqlString(criteria));
   return (TimePeriod) criteria.uniqueResult();
 }
Esempio n. 7
0
 @Override
 public GetDataAvailabilityResponse getDataAvailability(GetDataAvailabilityRequest req)
     throws OwsExceptionReport {
   Session session = sessionHolder.getSession();
   try {
     List<?> dataAvailabilityValues = queryDataAvailabilityValues(req, session);
     GetDataAvailabilityResponse response = new GetDataAvailabilityResponse();
     response.setService(req.getService());
     response.setVersion(req.getVersion());
     response.setNamespace(req.getNamespace());
     for (Object o : dataAvailabilityValues) {
       if (o != null) {
         response.addDataAvailability((DataAvailability) o);
       }
     }
     return response;
   } catch (HibernateException he) {
     throw new NoApplicableCodeException()
         .causedBy(he)
         .withMessage("Error while querying data for GetDataAvailability!");
   } finally {
     sessionHolder.returnSession(session);
   }
 }
Esempio n. 8
0
 /**
  * Check if optional count should be added
  *
  * @param request GetDataAvailability request
  * @return <code>true</code>, if optional count should be added
  */
 private boolean isShowCount(GetDataAvailabilityRequest request) {
   if (request.isSetExtensions()) {
     return request.getExtensions().isBooleanExtensionSet(SHOW_COUNT);
   }
   return isForceValueCount();
 }
Esempio n. 9
0
 private List<?> executeNamedQuery(GetDataAvailabilityRequest req, Session session) {
   final boolean features = req.isSetFeaturesOfInterest();
   final boolean observableProperties = req.isSetObservedProperties();
   final boolean procedures = req.isSetProcedures();
   String namedQueryName = null;
   Map<String, Collection<String>> parameter = Maps.newHashMap();
   // all
   if (features && observableProperties && procedures) {
     namedQueryName = SQL_QUERY_GET_DATA_AVAILABILITY_FOR_FEATURES_PROCEDURES_OBSERVED_PROPERTIES;
     parameter.put(FEATURES, req.getFeaturesOfInterest());
     parameter.put(OBSERVABLE_PROPERTIES, req.getObservedProperties());
     parameter.put(PROCEDURES, req.getProcedures());
   }
   // observableProperties and procedures
   else if (!features && observableProperties && procedures) {
     namedQueryName = SQL_QUERY_GET_DATA_AVAILABILITY_FOR_PROCEDURES_OBSERVED_PROPERTIES;
     parameter.put(OBSERVABLE_PROPERTIES, req.getObservedProperties());
     parameter.put(PROCEDURES, req.getProcedures());
   }
   // only observableProperties
   else if (!features && observableProperties && !procedures) {
     namedQueryName = SQL_QUERY_GET_DATA_AVAILABILITY_FOR_OBSERVED_PROPERTIES;
     parameter.put(OBSERVABLE_PROPERTIES, req.getObservedProperties());
   }
   // only procedures
   else if (!features && !observableProperties && procedures) {
     namedQueryName = SQL_QUERY_GET_DATA_AVAILABILITY_FOR_PROCEDURES;
     parameter.put(PROCEDURES, req.getProcedures());
   }
   // features and observableProperties
   else if (features && observableProperties && !procedures) {
     namedQueryName = SQL_QUERY_GET_DATA_AVAILABILITY_FOR_FEATURES_OBSERVED_PROPERTIES;
     parameter.put(FEATURES, req.getFeaturesOfInterest());
     parameter.put(OBSERVABLE_PROPERTIES, req.getObservedProperties());
   }
   // features and procedures
   else if (features && !observableProperties && procedures) {
     namedQueryName = SQL_QUERY_GET_DATA_AVAILABILITY_FOR_FEATURES_PROCEDURES;
     parameter.put(FEATURES, req.getFeaturesOfInterest());
     parameter.put(PROCEDURES, req.getProcedures());
   }
   // only features
   else if (features && !observableProperties && procedures) {
     namedQueryName = SQL_QUERY_GET_DATA_AVAILABILITY_FOR_FEATURES;
     parameter.put(FEATURES, req.getFeaturesOfInterest());
   }
   if (StringHelper.isNotEmpty(namedQueryName)) {
     Query namedQuery = session.getNamedQuery(namedQueryName);
     for (String key : parameter.keySet()) {
       namedQuery.setParameterList(key, parameter.get(key));
     }
     LOGGER.debug(
         "QUERY getProceduresForFeatureOfInterest(feature) with NamedQuery: {}", namedQuery);
     namedQuery.setResultTransformer(new DataAvailabilityTransformer(session));
     return namedQuery.list();
   }
   return Lists.newLinkedList();
 }