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

   1 /**
   2  * Copyright (c) 2010-2023 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.ArrayList;
  19 import java.util.Collections;
  20 import java.util.HashMap;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.Objects;
  24
  25 import org.eclipse.jdt.annotation.NonNullByDefault;
  26 import org.eclipse.jdt.annotation.Nullable;
  27 import org.openhab.binding.innogysmarthome.internal.client.InnogyClient;
  28 import org.openhab.binding.innogysmarthome.internal.client.entity.capability.Capability;
  29 import org.openhab.binding.innogysmarthome.internal.client.entity.capability.CapabilityState;
  30 import org.openhab.binding.innogysmarthome.internal.client.entity.device.Device;
  31 import org.openhab.binding.innogysmarthome.internal.client.entity.device.DeviceState;
  32 import org.openhab.binding.innogysmarthome.internal.client.entity.link.Link;
  33 import org.openhab.binding.innogysmarthome.internal.client.entity.location.Location;
  34 import org.openhab.binding.innogysmarthome.internal.client.entity.message.Message;
  35 import org.openhab.binding.innogysmarthome.internal.client.exception.ApiException;
  36 import org.openhab.binding.innogysmarthome.internal.client.exception.AuthenticationException;
  37 import org.slf4j.Logger;
  38 import org.slf4j.LoggerFactory;
  39
  40 /**
  41  * @author Sven Strohschein - Initial contribution (but only created by refactoring the InnogyClient class)
  42  */
  43 @NonNullByDefault
  44 public class FullDeviceManager {
  45
  46     private final Logger logger = LoggerFactory.getLogger(FullDeviceManager.class);
  47
  48     private final InnogyClient client;
  49
  50     public FullDeviceManager(InnogyClient client) {
  51         this.client = client;
  52     }
  53
  54     /**
  55      * Returns a {@link List} of all {@link Device}s with the full configuration details, {@link Capability}s and
  56      * states. Calling this may take a while...
  57      */
  58     public List<Device> getFullDevices() throws IOException, ApiException, AuthenticationException {
  59         final Map<String, Location> locationMap = createLocationMap(client);
  60         final Map<String, Capability> capabilityMap = createCapabilityMap(client);
  61         final Map<String, DeviceState> deviceStateMap = createDeviceStateMap(client);
  62         final Map<String, List<Message>> messageMap = createMessageMap(client);
  63
  64         final List<Device> deviceList = client.getDevices(deviceStateMap.keySet());
  65         for (final Device device : deviceList) {
  66             final String deviceId = device.getId();
  67             initializeDevice(device, deviceStateMap.get(deviceId), locationMap, capabilityMap,
  68                     getMessageList(device, messageMap));
  69         }
  70         return deviceList;
  71     }
  72
  73     /**
  74      * Returns the {@link Device} with the given deviceId with full configuration details, {@link Capability}s and
  75      * states. Calling this may take a little bit longer...
  76      */
  77     public Device getFullDeviceById(final String deviceId) throws IOException, ApiException, AuthenticationException {
  78         final Map<String, Location> locationMap = createLocationMap(client);
  79         final Map<String, Capability> capabilityMap = createCapabilityMap(deviceId, client);
  80         final List<Message> messageMap = createMessageMap(deviceId, client);
  81
  82         final DeviceState deviceState = new DeviceState();
  83         deviceState.setId(deviceId);
  84         deviceState.setState(client.getDeviceStateByDeviceId(deviceId));
  85
  86         final Device device = client.getDeviceById(deviceId);
  87         initializeDevice(device, deviceState, locationMap, capabilityMap, messageMap);
  88         return device;
  89     }
  90
  91     private void initializeDevice(Device device, @Nullable DeviceState deviceState, Map<String, Location> locationMap,
  92             Map<String, Capability> capabilityMap, List<Message> messageList) {
  93         device.setDeviceState(deviceState);
  94
  95         if (isBatteryPowered(device)) {
  96             device.setIsBatteryPowered(true);
  97         }
  98
  99         device.setLocation(locationMap.get(device.getLocationId()));
 100
 101         device.setCapabilityMap(createDeviceCapabilityMap(device, capabilityMap));
 102
 103         device.setMessageList(messageList);
 104     }
 105
 106     private static boolean isBatteryPowered(Device device) {
 107         return BATTERY_POWERED_DEVICES.contains(device.getType());
 108     }
 109
 110     private List<Message> getMessageList(Device device, Map<String, List<Message>> messageMap) {
 111         return Objects.requireNonNullElse(messageMap.get(device.getId()), Collections.emptyList());
 112     }
 113
 114     private static Map<String, Location> createLocationMap(InnogyClient client)
 115             throws IOException, ApiException, AuthenticationException {
 116         final List<Location> locationList = client.getLocations();
 117         final Map<String, Location> locationMap = new HashMap<>(locationList.size());
 118         for (final Location location : locationList) {
 119             locationMap.put(location.getId(), location);
 120         }
 121         return locationMap;
 122     }
 123
 124     private static Map<String, CapabilityState> createCapabilityStateMap(InnogyClient client)
 125             throws IOException, ApiException, AuthenticationException {
 126         final List<CapabilityState> capabilityStateList = client.getCapabilityStates();
 127         final Map<String, CapabilityState> capabilityStateMap = new HashMap<>(capabilityStateList.size());
 128         for (final CapabilityState capabilityState : capabilityStateList) {
 129             capabilityStateMap.put(capabilityState.getId(), capabilityState);
 130         }
 131         return capabilityStateMap;
 132     }
 133
 134     private static Map<String, Capability> createCapabilityMap(InnogyClient client)
 135             throws IOException, ApiException, AuthenticationException {
 136         final Map<String, CapabilityState> capabilityStateMap = createCapabilityStateMap(client);
 137         final List<Capability> capabilityList = client.getCapabilities();
 138
 139         return initializeCapabilities(capabilityStateMap, capabilityList);
 140     }
 141
 142     private static Map<String, Capability> createCapabilityMap(String deviceId, InnogyClient client)
 143             throws IOException, ApiException, AuthenticationException {
 144         final Map<String, CapabilityState> capabilityStateMap = createCapabilityStateMap(client);
 145         final List<Capability> capabilityList = client.getCapabilitiesForDevice(deviceId);
 146
 147         return initializeCapabilities(capabilityStateMap, capabilityList);
 148     }
 149
 150     private static Map<String, Capability> initializeCapabilities(Map<String, CapabilityState> capabilityStateMap,
 151             List<Capability> capabilityList) {
 152         final Map<String, Capability> capabilityMap = new HashMap<>(capabilityList.size());
 153         for (final Capability capability : capabilityList) {
 154             String capabilityId = capability.getId();
 155
 156             CapabilityState capabilityState = capabilityStateMap.get(capabilityId);
 157             capability.setCapabilityState(capabilityState);
 158
 159             capabilityMap.put(capabilityId, capability);
 160         }
 161         return capabilityMap;
 162     }
 163
 164     private static Map<String, Capability> createDeviceCapabilityMap(Device device,
 165             Map<String, Capability> capabilityMap) {
 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 }