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