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
  60         final Map<String, Location> locationMap = createLocationMap(client);
  61         final Map<String, Capability> capabilityMap = createCapabilityMap(client);
  62         final Map<String, DeviceState> deviceStateMap = createDeviceStateMap(client);
  63         final Map<String, List<Message>> messageMap = createMessageMap(client);
  64
  65         final List<Device> deviceList = client.getDevices(deviceStateMap.keySet());
  66         for (final Device device : deviceList) {
  67             final String deviceId = device.getId();
  68             initializeDevice(device, deviceStateMap.get(deviceId), locationMap, capabilityMap,
  69                     getMessageList(device, messageMap));
  70         }
  71         return deviceList;
  72     }
  73
  74     /**
  75      * Returns the {@link Device} with the given deviceId with full configuration details, {@link Capability}s and
  76      * states. Calling this may take a little bit longer...
  77      */
  78     public Device getFullDeviceById(final String deviceId) throws IOException, ApiException, AuthenticationException {
  79         final Map<String, Location> locationMap = createLocationMap(client);
  80         final Map<String, Capability> capabilityMap = createCapabilityMap(deviceId, client);
  81         final List<Message> messageMap = createMessageMap(deviceId, client);
  82
  83         final DeviceState deviceState = new DeviceState();
  84         deviceState.setId(deviceId);
  85         deviceState.setState(client.getDeviceStateByDeviceId(deviceId));
  86
  87         final Device device = client.getDeviceById(deviceId);
  88         initializeDevice(device, deviceState, locationMap, capabilityMap, messageMap);
  89         return device;
  90     }
  91
  92     private void initializeDevice(Device device, @Nullable DeviceState deviceState, Map<String, Location> locationMap,
  93             Map<String, Capability> capabilityMap, List<Message> messageList) {
  94
  95         device.setDeviceState(deviceState);
  96
  97         if (isBatteryPowered(device)) {
  98             device.setIsBatteryPowered(true);
  99         }
 100
 101         device.setLocation(locationMap.get(device.getLocationId()));
 102
 103         device.setCapabilityMap(createDeviceCapabilityMap(device, capabilityMap));
 104
 105         device.setMessageList(messageList);
 106     }
 107
 108     private static boolean isBatteryPowered(Device device) {
 109         return BATTERY_POWERED_DEVICES.contains(device.getType());
 110     }
 111
 112     private List<Message> getMessageList(Device device, Map<String, List<Message>> messageMap) {
 113         return Objects.requireNonNullElse(messageMap.get(device.getId()), Collections.emptyList());
 114     }
 115
 116     private static Map<String, Location> createLocationMap(InnogyClient client)
 117             throws IOException, ApiException, AuthenticationException {
 118         final List<Location> locationList = client.getLocations();
 119         final Map<String, Location> locationMap = new HashMap<>(locationList.size());
 120         for (final Location location : locationList) {
 121             locationMap.put(location.getId(), location);
 122         }
 123         return locationMap;
 124     }
 125
 126     private static Map<String, CapabilityState> createCapabilityStateMap(InnogyClient client)
 127             throws IOException, ApiException, AuthenticationException {
 128         final List<CapabilityState> capabilityStateList = client.getCapabilityStates();
 129         final Map<String, CapabilityState> capabilityStateMap = new HashMap<>(capabilityStateList.size());
 130         for (final CapabilityState capabilityState : capabilityStateList) {
 131             capabilityStateMap.put(capabilityState.getId(), capabilityState);
 132         }
 133         return capabilityStateMap;
 134     }
 135
 136     private static Map<String, Capability> createCapabilityMap(InnogyClient client)
 137             throws IOException, ApiException, AuthenticationException {
 138
 139         final Map<String, CapabilityState> capabilityStateMap = createCapabilityStateMap(client);
 140         final List<Capability> capabilityList = client.getCapabilities();
 141
 142         return initializeCapabilities(capabilityStateMap, capabilityList);
 143     }
 144
 145     private static Map<String, Capability> createCapabilityMap(String deviceId, InnogyClient client)
 146             throws IOException, ApiException, AuthenticationException {
 147
 148         final Map<String, CapabilityState> capabilityStateMap = createCapabilityStateMap(client);
 149         final List<Capability> capabilityList = client.getCapabilitiesForDevice(deviceId);
 150
 151         return initializeCapabilities(capabilityStateMap, capabilityList);
 152     }
 153
 154     private static Map<String, Capability> initializeCapabilities(Map<String, CapabilityState> capabilityStateMap,
 155             List<Capability> capabilityList) {
 156         final Map<String, Capability> capabilityMap = new HashMap<>(capabilityList.size());
 157         for (final Capability capability : capabilityList) {
 158             String capabilityId = capability.getId();
 159
 160             CapabilityState capabilityState = capabilityStateMap.get(capabilityId);
 161             capability.setCapabilityState(capabilityState);
 162
 163             capabilityMap.put(capabilityId, capability);
 164         }
 165         return capabilityMap;
 166     }
 167
 168     private static Map<String, Capability> createDeviceCapabilityMap(Device device,
 169             Map<String, Capability> capabilityMap) {
 170
 171         final HashMap<String, Capability> deviceCapabilityMap = new HashMap<>();
 172         for (final String capabilityValue : device.getCapabilities()) {
 173             final Capability capability = capabilityMap.get(Link.getId(capabilityValue));
 174             final String capabilityId = capability.getId();
 175             deviceCapabilityMap.put(capabilityId, capability);
 176         }
 177         return deviceCapabilityMap;
 178     }
 179
 180     private static Map<String, DeviceState> createDeviceStateMap(InnogyClient client)
 181             throws IOException, ApiException, AuthenticationException {
 182         final List<DeviceState> deviceStateList = client.getDeviceStates();
 183         final Map<String, DeviceState> deviceStateMap = new HashMap<>(deviceStateList.size());
 184         for (final DeviceState deviceState : deviceStateList) {
 185             deviceStateMap.put(deviceState.getId(), deviceState);
 186         }
 187         return deviceStateMap;
 188     }
 189
 190     private List<Message> createMessageMap(String deviceId, InnogyClient client)
 191             throws IOException, ApiException, AuthenticationException {
 192         final List<Message> messages = client.getMessages();
 193         final List<Message> messageList = new ArrayList<>();
 194         final String deviceIdPath = "/device/" + deviceId;
 195
 196         for (final Message message : messages) {
 197             logger.trace("Message Type {} with ID {}", message.getType(), message.getId());
 198             if (message.getDevices() != null && !message.getDevices().isEmpty()) {
 199                 for (final String li : message.getDevices()) {
 200                     if (deviceIdPath.equals(li)) {
 201                         messageList.add(message);
 202                     }
 203                 }
 204             }
 205         }
 206         return messageList;
 207     }
 208
 209     private static Map<String, List<Message>> createMessageMap(InnogyClient client)
 210             throws IOException, ApiException, AuthenticationException {
 211         final List<Message> messageList = client.getMessages();
 212         final Map<String, List<Message>> deviceMessageMap = new HashMap<>();
 213         for (final Message message : messageList) {
 214             if (message.getDevices() != null && !message.getDevices().isEmpty()) {
 215                 final String deviceId = message.getDevices().get(0).replace("/device/", "");
 216                 List<Message> ml;
 217                 if (deviceMessageMap.containsKey(deviceId)) {
 218                     ml = deviceMessageMap.get(deviceId);
 219                 } else {
 220                     ml = new ArrayList<>();
 221                 }
 222                 ml.add(message);
 223                 deviceMessageMap.put(deviceId, ml);
 224             }
 225         }
 226         return deviceMessageMap;
 227     }
 228 }