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

   1 /**
   2  * Copyright (c) 2010-2024 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.netatmo.internal.handler.capability;
  14
  15 import java.time.ZonedDateTime;
  16 import java.util.ArrayList;
  17 import java.util.Collection;
  18 import java.util.HashMap;
  19 import java.util.List;
  20 import java.util.Map;
  21 import java.util.Objects;
  22
  23 import org.eclipse.jdt.annotation.NonNullByDefault;
  24 import org.eclipse.jdt.annotation.Nullable;
  25 import org.openhab.binding.netatmo.internal.api.NetatmoException;
  26 import org.openhab.binding.netatmo.internal.api.SecurityApi;
  27 import org.openhab.binding.netatmo.internal.api.data.NetatmoConstants.FeatureArea;
  28 import org.openhab.binding.netatmo.internal.api.data.NetatmoConstants.FloodLightMode;
  29 import org.openhab.binding.netatmo.internal.api.dto.HomeData;
  30 import org.openhab.binding.netatmo.internal.api.dto.HomeDataModule;
  31 import org.openhab.binding.netatmo.internal.api.dto.HomeDataPerson;
  32 import org.openhab.binding.netatmo.internal.api.dto.HomeEvent;
  33 import org.openhab.binding.netatmo.internal.api.dto.HomeStatusModule;
  34 import org.openhab.binding.netatmo.internal.api.dto.HomeStatusPerson;
  35 import org.openhab.binding.netatmo.internal.api.dto.NAHomeStatus.HomeStatus;
  36 import org.openhab.binding.netatmo.internal.api.dto.NAObject;
  37 import org.openhab.binding.netatmo.internal.config.HomeConfiguration;
  38 import org.openhab.binding.netatmo.internal.deserialization.NAObjectMap;
  39 import org.openhab.binding.netatmo.internal.handler.CommonInterface;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42
  43 /**
  44  * The {@link SecurityCapability} is the base class for handler able to handle security features
  45  *
  46  * @author Gaël L'hopital - Initial contribution
  47  *
  48  */
  49 @NonNullByDefault
  50 class SecurityCapability extends RestCapability<SecurityApi> {
  51     private final Logger logger = LoggerFactory.getLogger(SecurityCapability.class);
  52
  53     private final Map<String, HomeEvent> eventBuffer = new HashMap<>();
  54     private @Nullable ZonedDateTime freshestEventTime;
  55
  56     private NAObjectMap<HomeDataPerson> persons = new NAObjectMap<>();
  57     private NAObjectMap<HomeDataModule> modules = new NAObjectMap<>();
  58     private String securityId = "";
  59
  60     SecurityCapability(CommonInterface handler) {
  61         super(handler, SecurityApi.class);
  62     }
  63
  64     @Override
  65     public void initialize() {
  66         super.initialize();
  67         freshestEventTime = null;
  68         securityId = handler.getThingConfigAs(HomeConfiguration.class).getIdForArea(FeatureArea.SECURITY);
  69     }
  70
  71     @Override
  72     protected void updateHomeData(HomeData homeData) {
  73         if (homeData instanceof HomeData.Security securityData) {
  74             persons = securityData.getPersons();
  75             modules = homeData.getModules();
  76             handler.getActiveChildren(FeatureArea.SECURITY).forEach(childHandler -> {
  77                 String childId = childHandler.getId();
  78                 persons.getOpt(childId).ifPresentOrElse(
  79                         personData -> childHandler.setNewData(personData.ignoringForThingUpdate()), () -> {
  80                             modules.getOpt(childId).ifPresent(
  81                                     childData -> childHandler.setNewData(childData.ignoringForThingUpdate()));
  82                             modules.values().stream().filter(module -> childId.equals(module.getBridge()))
  83                                     .forEach(bridgedModule -> childHandler.setNewData(bridgedModule));
  84                         });
  85             });
  86         }
  87     }
  88
  89     @Override
  90     protected void updateHomeStatus(HomeStatus securityStatus) {
  91         NAObjectMap<HomeStatusPerson> persons = securityStatus.getPersons();
  92         NAObjectMap<HomeStatusModule> modules = securityStatus.getModules();
  93         handler.getActiveChildren(FeatureArea.SECURITY).forEach(childHandler -> {
  94             String childId = childHandler.getId();
  95             persons.getOpt(childId).ifPresentOrElse(personData -> childHandler.setNewData(personData), () -> {
  96                 modules.getOpt(childId).ifPresent(childData -> {
  97                     childHandler.setNewData(childData);
  98                     modules.values().stream().filter(module -> childId.equals(module.getBridge()))
  99                             .forEach(bridgedModule -> childHandler.setNewData(bridgedModule));
 100                 });
 101             });
 102         });
 103     }
 104
 105     @Override
 106     protected void updateHomeEvent(HomeEvent homeEvent) {
 107         addEventIfKnownObject(homeEvent, homeEvent.getPersonId());
 108         addEventIfKnownObject(homeEvent, homeEvent.getCameraId());
 109     }
 110
 111     private void addEventIfKnownObject(HomeEvent homeEvent, @Nullable String objectId) {
 112         if (objectId == null) {
 113             return;
 114         }
 115         handler.getActiveChildren(FeatureArea.SECURITY).filter(child -> child.getId().equals(objectId))
 116                 .forEach(child -> child.setNewData(homeEvent));
 117     }
 118
 119     @Override
 120     protected List<NAObject> updateReadings(SecurityApi api) {
 121         List<NAObject> result = new ArrayList<>();
 122         try {
 123             for (HomeEvent event : api.getHomeEvents(securityId, freshestEventTime)) {
 124                 HomeEvent previousEvent = eventBuffer.get(event.getCameraId());
 125                 if (previousEvent == null || previousEvent.getTime().isBefore(event.getTime())) {
 126                     eventBuffer.put(event.getCameraId(), event);
 127                 }
 128                 String personId = event.getPersonId();
 129                 if (personId != null) {
 130                     previousEvent = eventBuffer.get(personId);
 131                     if (previousEvent == null || previousEvent.getTime().isBefore(event.getTime())) {
 132                         eventBuffer.put(personId, event);
 133                     }
 134                 }
 135                 if (freshestEventTime == null || event.getTime().isAfter(freshestEventTime)) {
 136                     freshestEventTime = event.getTime();
 137                 }
 138             }
 139         } catch (NetatmoException e) {
 140             logger.warn("Error retrieving last events for home '{}' : {}", securityId, e.getMessage());
 141         }
 142         return result;
 143     }
 144
 145     public NAObjectMap<HomeDataPerson> getPersons() {
 146         return persons;
 147     }
 148
 149     public NAObjectMap<HomeDataModule> getModules() {
 150         return modules;
 151     }
 152
 153     public @Nullable HomeEvent getLastPersonEvent(String personId) {
 154         HomeEvent event = eventBuffer.get(personId);
 155         if (event == null) {
 156             Collection<HomeEvent> events = requestPersonEvents(personId);
 157             if (!events.isEmpty()) {
 158                 event = events.iterator().next();
 159                 eventBuffer.put(personId, event);
 160             }
 161         }
 162         return event;
 163     }
 164
 165     public @Nullable HomeEvent getDeviceLastEvent(String moduleId, String deviceType) {
 166         HomeEvent event = eventBuffer.get(moduleId);
 167         if (event == null) {
 168             Collection<HomeEvent> events = requestDeviceEvents(moduleId, deviceType);
 169             if (!events.isEmpty()) {
 170                 event = events.iterator().next();
 171                 eventBuffer.put(moduleId, event);
 172             }
 173         }
 174         return event;
 175     }
 176
 177     private Collection<HomeEvent> requestDeviceEvents(String moduleId, String deviceType) {
 178         return Objects.requireNonNull(getApi().map(api -> {
 179             try {
 180                 return api.getDeviceEvents(securityId, moduleId, deviceType);
 181             } catch (NetatmoException e) {
 182                 logger.warn("Error retrieving last events of camera '{}' : {}", moduleId, e.getMessage());
 183                 return null;
 184             }
 185         }).orElse(List.of()));
 186     }
 187
 188     private Collection<HomeEvent> requestPersonEvents(String personId) {
 189         return Objects.requireNonNull(getApi().map(api -> {
 190             try {
 191                 return api.getPersonEvents(securityId, personId);
 192             } catch (NetatmoException e) {
 193                 logger.warn("Error retrieving last events of person '{}' : {}", personId, e.getMessage());
 194                 return null;
 195             }
 196         }).orElse(List.of()));
 197     }
 198
 199     public void setPersonAway(String personId, boolean away) {
 200         getApi().ifPresent(api -> {
 201             try {
 202                 api.setPersonAwayStatus(securityId, personId, away);
 203                 handler.expireData();
 204             } catch (NetatmoException e) {
 205                 logger.warn("Error setting person away/at home '{}' : {}", personId, e.getMessage());
 206             }
 207         });
 208     }
 209
 210     public @Nullable String ping(String vpnUrl) {
 211         return getApi().map(api -> api.ping(vpnUrl)).orElse(null);
 212     }
 213
 214     public void changeStatus(@Nullable String localURL, boolean status) {
 215         if (localURL == null) {
 216             logger.info("Monitoring changes can only be done on local camera.");
 217             return;
 218         }
 219         getApi().ifPresent(api -> {
 220             try {
 221                 api.changeStatus(localURL, status);
 222                 handler.expireData();
 223             } catch (NetatmoException e) {
 224                 logger.warn("Error changing camera monitoring status '{}' : {}", status, e.getMessage());
 225             }
 226         });
 227     }
 228
 229     public void changeFloodlightMode(String cameraId, FloodLightMode mode) {
 230         getApi().ifPresent(api -> {
 231             try {
 232                 api.changeFloodLightMode(securityId, cameraId, mode);
 233                 handler.expireData();
 234             } catch (NetatmoException e) {
 235                 logger.warn("Error changing Presence floodlight mode '{}' : {}", mode, e.getMessage());
 236             }
 237         });
 238     }
 239 }