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.binding.innogysmarthome.internal.manager;
  14
  15 import static org.openhab.binding.innogysmarthome.internal.InnogyBindingConstants.BATTERY_POWERED_DEVICES;
  16
  17 import java.io.IOException;
  18 import java.util.*;
  19
  20 import org.eclipse.jdt.annotation.NonNullByDefault;
  21 import org.eclipse.jdt.annotation.Nullable;
  22 import org.openhab.binding.innogysmarthome.internal.client.InnogyClient;
  23 import org.openhab.binding.innogysmarthome.internal.client.entity.capability.Capability;
  24 import org.openhab.binding.innogysmarthome.internal.client.entity.capability.CapabilityState;
  25 import org.openhab.binding.innogysmarthome.internal.client.entity.device.Device;
  26 import org.openhab.binding.innogysmarthome.internal.client.entity.device.DeviceState;
  27 import org.openhab.binding.innogysmarthome.internal.client.entity.link.Link;
  28 import org.openhab.binding.innogysmarthome.internal.client.entity.location.Location;
  29 import org.openhab.binding.innogysmarthome.internal.client.entity.message.Message;
  30 import org.openhab.binding.innogysmarthome.internal.client.exception.ApiException;
  31 import org.openhab.binding.innogysmarthome.internal.client.exception.AuthenticationException;
  32 import org.slf4j.Logger;
  33 import org.slf4j.LoggerFactory;
  34
  35 /**
  36  * @author Sven Strohschein - Initial contribution (but only created by refactoring the InnogyClient class)
  37  */
  38 @NonNullByDefault
  39 public class FullDeviceManager {
  40
  41     private final Logger logger = LoggerFactory.getLogger(FullDeviceManager.class);
  42
  43     private final InnogyClient client;
  44
  45     public FullDeviceManager(InnogyClient client) {
  46         this.client = client;
  47     }
  48
  49     /**
  50      * Returns a {@link List} of all {@link Device}s with the full configuration details, {@link Capability}s and
  51      * states. Calling this may take a while...
  52      */
  53     public List<Device> getFullDevices() throws IOException, ApiException, AuthenticationException {
  54
  55         final Map<String, Location> locationMap = createLocationMap(client);
  56         final Map<String, Capability> capabilityMap = createCapabilityMap(client);
  57         final Map<String, DeviceState> deviceStateMap = createDeviceStateMap(client);
  58         final Map<String, List<Message>> messageMap = createMessageMap(client);
  59
  60         final List<Device> deviceList = client.getDevices(deviceStateMap.keySet());
  61         for (final Device device : deviceList) {
  62             final String deviceId = device.getId();
  63             initializeDevice(device, deviceStateMap.get(deviceId), locationMap, capabilityMap,
  64                     getMessageList(device, messageMap));
  65         }
  66         return deviceList;
  67     }
  68
  69     /**
  70      * Returns the {@link Device} with the given deviceId with full configuration details, {@link Capability}s and
  71      * states. Calling this may take a little bit longer...
  72      */
  73     public Device getFullDeviceById(final String deviceId) throws IOException, ApiException, AuthenticationException {
  74         final Map<String, Location> locationMap = createLocationMap(client);
  75         final Map<String, Capability> capabilityMap = createCapabilityMap(deviceId, client);
  76         final List<Message> messageMap = createMessageMap(deviceId, client);
  77
  78         final DeviceState deviceState = new DeviceState();
  79         deviceState.setId(deviceId);
  80         deviceState.setState(client.getDeviceStateByDeviceId(deviceId));
  81
  82         final Device device = client.getDeviceById(deviceId);
  83         initializeDevice(device, deviceState, locationMap, capabilityMap, messageMap);
  84         return device;
  85     }
  86
  87     private void initializeDevice(Device device, @Nullable DeviceState deviceState, Map<String, Location> locationMap,
  88             Map<String, Capability> capabilityMap, List<Message> messageList) {
  89
  90         device.setDeviceState(deviceState);
  91
  92         if (isBatteryPowered(device)) {
  93             device.setIsBatteryPowered(true);
  94         }
  95
  96         device.setLocation(locationMap.get(device.getLocationId()));
  97
  98         device.setCapabilityMap(createDeviceCapabilityMap(device, capabilityMap));
  99
 100         device.setMessageList(messageList);
 101     }
 102
 103     private static boolean isBatteryPowered(Device device) {
 104         return BATTERY_POWERED_DEVICES.contains(device.getType());
 105     }
 106
 107     private List<Message> getMessageList(Device device, Map<String, List<Message>> messageMap) {
 108         return Objects.requireNonNullElse(messageMap.get(device.getId()), Collections.emptyList());
 109     }
 110
 111     private static Map<String, Location> createLocationMap(InnogyClient client)
 112             throws IOException, ApiException, AuthenticationException {
 113         final List<Location> locationList = client.getLocations();
 114         final Map<String, Location> locationMap = new HashMap<>(locationList.size());
 115         for (final Location location : locationList) {
 116             locationMap.put(location.getId(), location);
 117         }
 118         return locationMap;
 119     }
 120
 121     private static Map<String, CapabilityState> createCapabilityStateMap(InnogyClient client)
 122             throws IOException, ApiException, AuthenticationException {
 123         final List<CapabilityState> capabilityStateList = client.getCapabilityStates();
 124         final Map<String, CapabilityState> capabilityStateMap = new HashMap<>(capabilityStateList.size());
 125         for (final CapabilityState capabilityState : capabilityStateList) {
 126             capabilityStateMap.put(capabilityState.getId(), capabilityState);
 127         }
 128         return capabilityStateMap;
 129     }
 130
 131     private static Map<String, Capability> createCapabilityMap(InnogyClient client)
 132             throws IOException, ApiException, AuthenticationException {
 133
 134         final Map<String, CapabilityState> capabilityStateMap = createCapabilityStateMap(client);
 135         final List<Capability> capabilityList = client.getCapabilities();
 136
 137         return initializeCapabilities(capabilityStateMap, capabilityList);
 138     }
 139
 140     private static Map<String, Capability> createCapabilityMap(String deviceId, InnogyClient client)
 141             throws IOException, ApiException, AuthenticationException {
 142
 143         final Map<String, CapabilityState> capabilityStateMap = createCapabilityStateMap(client);
 144         final List<Capability> capabilityList = client.getCapabilitiesForDevice(deviceId);
 145
 146         return initializeCapabilities(capabilityStateMap, capabilityList);
 147     }
 148
 149     private static Map<String, Capability> initializeCapabilities(Map<String, CapabilityState> capabilityStateMap,
 150             List<Capability> capabilityList) {
 151         final Map<String, Capability> capabilityMap = new HashMap<>(capabilityList.size());
 152         for (final Capability capability : capabilityList) {
 153             String capabilityId = capability.getId();
 154
 155             CapabilityState capabilityState = capabilityStateMap.get(capabilityId);
 156             capability.setCapabilityState(capabilityState);
 157
 158             capabilityMap.put(capabilityId, capability);
 159         }
 160         return capabilityMap;
 161     }
 162
 163     private static Map<String, Capability> createDeviceCapabilityMap(Device device,
 164             Map<String, Capability> capabilityMap) {
 165
 166         final HashMap<String, Capability> deviceCapabilityMap = new HashMap<>();
 167         for (final String capabilityValue : device.getCapabilities()) {
 168             final Capability capability = capabilityMap.get(Link.getId(capabilityValue));
 169             final String capabilityId = capability.getId();
 170             deviceCapabilityMap.put(capabilityId, capability);
 171         }
 172         return deviceCapabilityMap;
 173     }
 174
 175     private static Map<String, DeviceState> createDeviceStateMap(InnogyClient client)
 176             throws IOException, ApiException, AuthenticationException {
 177         final List<DeviceState> deviceStateList = client.getDeviceStates();
 178         final Map<String, DeviceState> deviceStateMap = new HashMap<>(deviceStateList.size());
 179         for (final DeviceState deviceState : deviceStateList) {
 180             deviceStateMap.put(deviceState.getId(), deviceState);
 181         }
 182         return deviceStateMap;
 183     }
 184
 185     private List<Message> createMessageMap(String deviceId, InnogyClient client)
 186             throws IOException, ApiException, AuthenticationException {
 187         final List<Message> messages = client.getMessages();
 188         final List<Message> messageList = new ArrayList<>();
 189         final String deviceIdPath = "/device/" + deviceId;
 190
 191         for (final Message message : messages) {
 192             logger.trace("Message Type {} with ID {}", message.getType(), message.getId());
 193             if (message.getDevices() != null && !message.getDevices().isEmpty()) {
 194                 for (final String li : message.getDevices()) {
 195                     if (deviceIdPath.equals(li)) {
 196                         messageList.add(message);
 197                     }
 198                 }
 199             }
 200         }
 201         return messageList;
 202     }
 203
 204     private static Map<String, List<Message>> createMessageMap(InnogyClient client)
 205             throws IOException, ApiException, AuthenticationException {
 206         final List<Message> messageList = client.getMessages();
 207         final Map<String, List<Message>> deviceMessageMap = new HashMap<>();
 208         for (final Message message : messageList) {
 209             if (message.getDevices() != null && !message.getDevices().isEmpty()) {
 210                 final String deviceId = message.getDevices().get(0).replace("/device/", "");
 211                 List<Message> ml;
 212                 if (deviceMessageMap.containsKey(deviceId)) {
 213                     ml = deviceMessageMap.get(deviceId);
 214                 } else {
 215                     ml = new ArrayList<>();
 216                 }
 217                 ml.add(message);
 218                 deviceMessageMap.put(deviceId, ml);
 219             }
 220         }
 221         return deviceMessageMap;
 222     }
 223 }