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

   1 /**
   2  * Copyright (c) 2010-2022 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.util.Collection;
  16 import java.util.List;
  17
  18 import org.eclipse.jdt.annotation.NonNullByDefault;
  19 import org.eclipse.jdt.annotation.Nullable;
  20 import org.openhab.binding.netatmo.internal.api.NetatmoException;
  21 import org.openhab.binding.netatmo.internal.api.SecurityApi;
  22 import org.openhab.binding.netatmo.internal.api.data.NetatmoConstants.FloodLightMode;
  23 import org.openhab.binding.netatmo.internal.api.dto.HomeData;
  24 import org.openhab.binding.netatmo.internal.api.dto.HomeDataModule;
  25 import org.openhab.binding.netatmo.internal.api.dto.HomeDataPerson;
  26 import org.openhab.binding.netatmo.internal.api.dto.HomeEvent;
  27 import org.openhab.binding.netatmo.internal.api.dto.HomeStatusModule;
  28 import org.openhab.binding.netatmo.internal.api.dto.HomeStatusPerson;
  29 import org.openhab.binding.netatmo.internal.api.dto.NAHomeStatus.HomeStatus;
  30 import org.openhab.binding.netatmo.internal.deserialization.NAObjectMap;
  31 import org.openhab.binding.netatmo.internal.handler.CommonInterface;
  32 import org.slf4j.Logger;
  33 import org.slf4j.LoggerFactory;
  34
  35 /**
  36  * The {@link SecurityCapability} is the base class for handler able to handle security features
  37  *
  38  * @author Gaël L'hopital - Initial contribution
  39  *
  40  */
  41 @NonNullByDefault
  42 class SecurityCapability extends RestCapability<SecurityApi> {
  43     private final Logger logger = LoggerFactory.getLogger(SecurityCapability.class);
  44
  45     SecurityCapability(CommonInterface handler) {
  46         super(handler, SecurityApi.class);
  47     }
  48
  49     @Override
  50     protected void updateHomeData(HomeData homeData) {
  51         NAObjectMap<HomeDataPerson> persons = homeData.getPersons();
  52         NAObjectMap<HomeDataModule> modules = homeData.getModules();
  53         handler.getActiveChildren().forEach(childHandler -> {
  54             String childId = childHandler.getId();
  55             persons.getOpt(childId).ifPresentOrElse(personData -> {
  56                 personData.setIgnoredForThingUpdate(true);
  57                 childHandler.setNewData(personData);
  58             }, () -> {
  59                 modules.getOpt(childId).ifPresent(childData -> {
  60                     childData.setIgnoredForThingUpdate(true);
  61                     childHandler.setNewData(childData);
  62                 });
  63                 modules.values().stream().filter(module -> childId.equals(module.getBridge()))
  64                         .forEach(bridgedModule -> {
  65                             childHandler.setNewData(bridgedModule);
  66                         });
  67             });
  68         });
  69     }
  70
  71     @Override
  72     protected void updateHomeStatus(HomeStatus homeStatus) {
  73         NAObjectMap<HomeStatusPerson> persons = homeStatus.getPersons();
  74         NAObjectMap<HomeStatusModule> modules = homeStatus.getModules();
  75         handler.getActiveChildren().forEach(childHandler -> {
  76             String childId = childHandler.getId();
  77             persons.getOpt(childId).ifPresentOrElse(personData -> childHandler.setNewData(personData), () -> {
  78                 modules.getOpt(childId).ifPresentOrElse(childData -> {
  79                     childHandler.setNewData(childData);
  80                     modules.values().stream().filter(module -> childId.equals(module.getBridge()))
  81                             .forEach(bridgedModule -> {
  82                                 childHandler.setNewData(bridgedModule);
  83                             });
  84
  85                 }, () -> {
  86                     // This module is not present in the homestatus data, so it is considered as unreachable
  87                     HomeStatusModule module = new HomeStatusModule();
  88                     module.setReachable(false);
  89                     childHandler.setNewData(module);
  90                 });
  91             });
  92         });
  93     }
  94
  95     @Override
  96     protected void updateHomeEvent(HomeEvent homeEvent) {
  97         String personId = homeEvent.getPersonId();
  98         if (personId != null) {
  99             handler.getActiveChildren().stream().filter(handler -> personId.equals(handler.getId())).findFirst()
 100                     .ifPresent(handler -> {
 101                         homeEvent.setIgnoredForThingUpdate(true);
 102                         handler.setNewData(homeEvent);
 103                     });
 104         }
 105         String cameraId = homeEvent.getCameraId();
 106         handler.getActiveChildren().stream().filter(handler -> cameraId.equals(handler.getId())).findFirst()
 107                 .ifPresent(handler -> {
 108                     homeEvent.setIgnoredForThingUpdate(true);
 109                     handler.setNewData(homeEvent);
 110                 });
 111     }
 112
 113     public Collection<HomeEvent> getDeviceEvents(String cameraId, String deviceType) {
 114         return getApi().map(api -> {
 115             try {
 116                 return api.getDeviceEvents(handler.getId(), cameraId, deviceType);
 117             } catch (NetatmoException e) {
 118                 logger.warn("Error retrieving last events of camera '{}' : {}", cameraId, e.getMessage());
 119                 return null;
 120             }
 121         }).orElse(List.of());
 122     }
 123
 124     public Collection<HomeEvent> getPersonEvents(String personId) {
 125         return getApi().map(api -> {
 126             try {
 127                 return api.getPersonEvents(handler.getId(), personId);
 128             } catch (NetatmoException e) {
 129                 logger.warn("Error retrieving last events of person '{}' : {}", personId, e.getMessage());
 130                 return null;
 131             }
 132         }).orElse(List.of());
 133     }
 134
 135     public void setPersonAway(String personId, boolean away) {
 136         getApi().ifPresent(api -> {
 137             try {
 138                 api.setPersonAwayStatus(handler.getId(), personId, away);
 139                 handler.expireData();
 140             } catch (NetatmoException e) {
 141                 logger.warn("Error setting person away/at home '{}' : {}", personId, e.getMessage());
 142             }
 143         });
 144     }
 145
 146     public @Nullable String ping(String vpnUrl) {
 147         return getApi().map(api -> {
 148             try {
 149                 return api.ping(vpnUrl);
 150             } catch (NetatmoException e) {
 151                 logger.warn("Error pinging camera '{}' : {}", vpnUrl, e.getMessage());
 152                 return null;
 153             }
 154         }).orElse(null);
 155     }
 156
 157     public void changeStatus(@Nullable String localURL, boolean status) {
 158         if (localURL == null) {
 159             logger.info("Monitoring changes can only be done on local camera.");
 160             return;
 161         }
 162         getApi().ifPresent(api -> {
 163             try {
 164                 api.changeStatus(localURL, status);
 165                 handler.expireData();
 166             } catch (NetatmoException e) {
 167                 logger.warn("Error changing camera monitoring status '{}' : {}", status, e.getMessage());
 168             }
 169         });
 170     }
 171
 172     public void changeFloodlightMode(String cameraId, FloodLightMode mode) {
 173         getApi().ifPresent(api -> {
 174             try {
 175                 api.changeFloodLightMode(handler.getId(), cameraId, mode);
 176                 handler.expireData();
 177             } catch (NetatmoException e) {
 178                 logger.warn("Error changing Presence floodlight mode '{}' : {}", mode, e.getMessage());
 179             }
 180         });
 181     }
 182 }