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.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
  22 import org.eclipse.jdt.annotation.NonNullByDefault;
  23 import org.eclipse.jdt.annotation.Nullable;
  24 import org.openhab.binding.netatmo.internal.api.NetatmoException;
  25 import org.openhab.binding.netatmo.internal.api.SecurityApi;
  26 import org.openhab.binding.netatmo.internal.api.data.NetatmoConstants.FeatureArea;
  27 import org.openhab.binding.netatmo.internal.api.data.NetatmoConstants.FloodLightMode;
  28 import org.openhab.binding.netatmo.internal.api.dto.HomeData;
  29 import org.openhab.binding.netatmo.internal.api.dto.HomeDataModule;
  30 import org.openhab.binding.netatmo.internal.api.dto.HomeDataPerson;
  31 import org.openhab.binding.netatmo.internal.api.dto.HomeEvent;
  32 import org.openhab.binding.netatmo.internal.api.dto.HomeStatusModule;
  33 import org.openhab.binding.netatmo.internal.api.dto.HomeStatusPerson;
  34 import org.openhab.binding.netatmo.internal.api.dto.NAHomeStatus;
  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.getConfiguration().as(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 homeStatus) {
  91         if (homeStatus instanceof NAHomeStatus.Security securityStatus) {
  92             NAObjectMap<HomeStatusPerson> persons = securityStatus.getPersons();
  93             NAObjectMap<HomeStatusModule> modules = securityStatus.getModules();
  94             handler.getActiveChildren(FeatureArea.SECURITY).forEach(childHandler -> {
  95                 String childId = childHandler.getId();
  96                 persons.getOpt(childId).ifPresentOrElse(personData -> childHandler.setNewData(personData), () -> {
  97                     modules.getOpt(childId).ifPresent(childData -> {
  98                         childHandler.setNewData(childData);
  99                         modules.values().stream().filter(module -> childId.equals(module.getBridge()))
 100                                 .forEach(bridgedModule -> childHandler.setNewData(bridgedModule));
 101                     });
 102                 });
 103             });
 104         }
 105     }
 106
 107     @Override
 108     protected void updateHomeEvent(HomeEvent homeEvent) {
 109         addEventIfKnownObject(homeEvent, homeEvent.getPersonId());
 110         addEventIfKnownObject(homeEvent, homeEvent.getCameraId());
 111     }
 112
 113     private void addEventIfKnownObject(HomeEvent homeEvent, @Nullable String objectId) {
 114         if (objectId == null) {
 115             return;
 116         }
 117         handler.getActiveChildren(FeatureArea.SECURITY).filter(child -> child.getId().equals(objectId))
 118                 .forEach(child -> child.setNewData(homeEvent.ignoringForThingUpdate()));
 119     }
 120
 121     @Override
 122     protected List<NAObject> updateReadings(SecurityApi api) {
 123         List<NAObject> result = new ArrayList<>();
 124         try {
 125             for (HomeEvent event : api.getHomeEvents(securityId, freshestEventTime)) {
 126                 HomeEvent previousEvent = eventBuffer.get(event.getCameraId());
 127                 if (previousEvent == null || previousEvent.getTime().isBefore(event.getTime())) {
 128                     eventBuffer.put(event.getCameraId(), event);
 129                 }
 130                 String personId = event.getPersonId();
 131                 if (personId != null) {
 132                     previousEvent = eventBuffer.get(personId);
 133                     if (previousEvent == null || previousEvent.getTime().isBefore(event.getTime())) {
 134                         eventBuffer.put(personId, event);
 135                     }
 136                 }
 137                 if (freshestEventTime == null || event.getTime().isAfter(freshestEventTime)) {
 138                     freshestEventTime = event.getTime();
 139                 }
 140             }
 141         } catch (NetatmoException e) {
 142             logger.warn("Error retrieving last events for home '{}' : {}", securityId, e.getMessage());
 143         }
 144         return result;
 145     }
 146
 147     public NAObjectMap<HomeDataPerson> getPersons() {
 148         return persons;
 149     }
 150
 151     public NAObjectMap<HomeDataModule> getModules() {
 152         return modules;
 153     }
 154
 155     public @Nullable HomeEvent getLastPersonEvent(String personId) {
 156         HomeEvent event = eventBuffer.get(personId);
 157         if (event == null) {
 158             Collection<HomeEvent> events = requestPersonEvents(personId);
 159             if (!events.isEmpty()) {
 160                 event = events.iterator().next();
 161                 eventBuffer.put(personId, event);
 162             }
 163         }
 164         return event;
 165     }
 166
 167     public @Nullable HomeEvent getDeviceLastEvent(String moduleId, String deviceType) {
 168         HomeEvent event = eventBuffer.get(moduleId);
 169         if (event == null) {
 170             Collection<HomeEvent> events = requestDeviceEvents(moduleId, deviceType);
 171             if (!events.isEmpty()) {
 172                 event = events.iterator().next();
 173                 eventBuffer.put(moduleId, event);
 174             }
 175         }
 176         return event;
 177     }
 178
 179     private Collection<HomeEvent> requestDeviceEvents(String moduleId, String deviceType) {
 180         return getApi().map(api -> {
 181             try {
 182                 return api.getDeviceEvents(securityId, moduleId, deviceType);
 183             } catch (NetatmoException e) {
 184                 logger.warn("Error retrieving last events of camera '{}' : {}", moduleId, e.getMessage());
 185                 return null;
 186             }
 187         }).orElse(List.of());
 188     }
 189
 190     private Collection<HomeEvent> requestPersonEvents(String personId) {
 191         return getApi().map(api -> {
 192             try {
 193                 return api.getPersonEvents(securityId, personId);
 194             } catch (NetatmoException e) {
 195                 logger.warn("Error retrieving last events of person '{}' : {}", personId, e.getMessage());
 196                 return null;
 197             }
 198         }).orElse(List.of());
 199     }
 200
 201     public void setPersonAway(String personId, boolean away) {
 202         getApi().ifPresent(api -> {
 203             try {
 204                 api.setPersonAwayStatus(securityId, personId, away);
 205                 handler.expireData();
 206             } catch (NetatmoException e) {
 207                 logger.warn("Error setting person away/at home '{}' : {}", personId, e.getMessage());
 208             }
 209         });
 210     }
 211
 212     public @Nullable String ping(String vpnUrl) {
 213         return getApi().map(api -> api.ping(vpnUrl)).orElse(null);
 214     }
 215
 216     public void changeStatus(@Nullable String localURL, boolean status) {
 217         if (localURL == null) {
 218             logger.info("Monitoring changes can only be done on local camera.");
 219             return;
 220         }
 221         getApi().ifPresent(api -> {
 222             try {
 223                 api.changeStatus(localURL, status);
 224                 handler.expireData();
 225             } catch (NetatmoException e) {
 226                 logger.warn("Error changing camera monitoring status '{}' : {}", status, e.getMessage());
 227             }
 228         });
 229     }
 230
 231     public void changeFloodlightMode(String cameraId, FloodLightMode mode) {
 232         getApi().ifPresent(api -> {
 233             try {
 234                 api.changeFloodLightMode(securityId, cameraId, mode);
 235                 handler.expireData();
 236             } catch (NetatmoException e) {
 237                 logger.warn("Error changing Presence floodlight mode '{}' : {}", mode, e.getMessage());
 238             }
 239         });
 240     }
 241 }