git.basschouten.com Git - openhab-addons.git/blob

   1 /**
   2  * Copyright (c) 2010-2021 Contributors to the openHAB project
   3  *
   4  * See the NOTICE file(s) distributed with this work for additional
   5  * information.
   6  *
   7  * This program and the accompanying materials are made available under the
   8  * terms of the Eclipse Public License 2.0 which is available at
   9  * http://www.eclipse.org/legal/epl-2.0
  10  *
  11  * SPDX-License-Identifier: EPL-2.0
  12  */
  13 package org.openhab.io.imperihome.internal.handler;
  14
  15 import java.io.UnsupportedEncodingException;
  16 import java.net.URLDecoder;
  17 import java.time.Instant;
  18 import java.time.ZoneId;
  19 import java.time.ZonedDateTime;
  20 import java.util.Iterator;
  21 import java.util.LinkedList;
  22 import java.util.List;
  23 import java.util.regex.Matcher;
  24
  25 import javax.servlet.http.HttpServletRequest;
  26
  27 import org.openhab.core.library.types.DecimalType;
  28 import org.openhab.core.persistence.FilterCriteria;
  29 import org.openhab.core.persistence.HistoricItem;
  30 import org.openhab.core.persistence.PersistenceService;
  31 import org.openhab.core.persistence.PersistenceServiceRegistry;
  32 import org.openhab.core.persistence.QueryablePersistenceService;
  33 import org.openhab.core.types.State;
  34 import org.openhab.io.imperihome.internal.model.HistoryItem;
  35 import org.openhab.io.imperihome.internal.model.HistoryList;
  36 import org.openhab.io.imperihome.internal.model.device.AbstractDevice;
  37 import org.openhab.io.imperihome.internal.processor.DeviceRegistry;
  38 import org.slf4j.Logger;
  39 import org.slf4j.LoggerFactory;
  40
  41 /**
  42  * Device history request handler.
  43  *
  44  * @author Pepijn de Geus - Initial contribution
  45  */
  46 public class DeviceHistoryHandler {
  47
  48     private static final String CHARSET = "UTF-8";
  49
  50     private final Logger logger = LoggerFactory.getLogger(DeviceHistoryHandler.class);
  51
  52     private final DeviceRegistry deviceRegistry;
  53     private final PersistenceServiceRegistry persistenceServiceRegistry;
  54
  55     public DeviceHistoryHandler(DeviceRegistry deviceRegistry, PersistenceServiceRegistry persistenceServiceRegistry) {
  56         this.deviceRegistry = deviceRegistry;
  57         this.persistenceServiceRegistry = persistenceServiceRegistry;
  58     }
  59
  60     public HistoryList handle(HttpServletRequest req, Matcher urlMatcher) {
  61         String deviceId, field;
  62         long start, end;
  63         try {
  64             deviceId = URLDecoder.decode(urlMatcher.group(1), CHARSET);
  65             field = URLDecoder.decode(urlMatcher.group(2), CHARSET);
  66             start = Long.parseLong(urlMatcher.group(3));
  67             end = Long.parseLong(urlMatcher.group(4));
  68         } catch (UnsupportedEncodingException | NumberFormatException e) {
  69             throw new RuntimeException("Could not decode request params", e);
  70         }
  71
  72         logger.debug("History request for device {}, field {}: {}-{}", deviceId, field, start, end);
  73
  74         AbstractDevice device = deviceRegistry.getDevice(deviceId);
  75         if (device == null) {
  76             logger.warn("Received history request for unknown device: {}", urlMatcher.group(0));
  77             return null;
  78         }
  79
  80         PersistenceService persistence = persistenceServiceRegistry.getDefault();
  81         if (persistence == null) {
  82             logger.warn("Could not retrieve default persistence service; can't serve history request");
  83             return null;
  84         }
  85         if (!(persistence instanceof QueryablePersistenceService)) {
  86             logger.warn("Default persistence service is not queryable; can't serve history request");
  87             return null;
  88         }
  89
  90         return serveHistory(device, (QueryablePersistenceService) persistence, start, end);
  91     }
  92
  93     private HistoryList serveHistory(AbstractDevice device, QueryablePersistenceService persistence, long start,
  94             long end) {
  95         logger.info("Querying persistence for history of Item {}, from {} to {}", device.getItemName(), start, end);
  96
  97         FilterCriteria criteria = new FilterCriteria().setItemName(device.getItemName())
  98                 .setBeginDate(ZonedDateTime.ofInstant(Instant.ofEpochMilli(start), ZoneId.systemDefault()))
  99                 .setEndDate(ZonedDateTime.ofInstant(Instant.ofEpochMilli(end), ZoneId.systemDefault()));
 100
 101         List<HistoryItem> resultItems = new LinkedList<>();
 102         Iterable<HistoricItem> historicItems = persistence.query(criteria);
 103
 104         Iterator<HistoricItem> iterator = historicItems.iterator();
 105         if (!iterator.hasNext()) {
 106             logger.info("Persistence returned no results for history query");
 107         } else {
 108             while (iterator.hasNext()) {
 109                 HistoricItem historicItem = iterator.next();
 110                 State state = historicItem.getState();
 111                 if (state instanceof DecimalType) {
 112                     Number value = ((DecimalType) state).toBigDecimal();
 113                     resultItems.add(new HistoryItem(historicItem.getTimestamp().toInstant().toEpochMilli(), value));
 114                 }
 115             }
 116
 117             if (resultItems.isEmpty()) {
 118                 logger.warn(
 119                         "Persistence returned results for history query, but could not be interpreted as DecimalTypes");
 120             }
 121         }
 122
 123         return new HistoryList(resultItems);
 124     }
 125 }