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.nuki.internal.dataexchange;
  14
  15 import java.io.BufferedReader;
  16 import java.io.IOException;
  17 import java.nio.charset.StandardCharsets;
  18 import java.util.ArrayList;
  19 import java.util.Dictionary;
  20 import java.util.Hashtable;
  21 import java.util.List;
  22
  23 import javax.servlet.ServletException;
  24 import javax.servlet.http.HttpServlet;
  25 import javax.servlet.http.HttpServletRequest;
  26 import javax.servlet.http.HttpServletResponse;
  27
  28 import org.eclipse.jdt.annotation.NonNullByDefault;
  29 import org.eclipse.jdt.annotation.Nullable;
  30 import org.eclipse.jetty.http.HttpStatus;
  31 import org.openhab.binding.nuki.internal.constants.NukiBindingConstants;
  32 import org.openhab.binding.nuki.internal.constants.NukiLinkBuilder;
  33 import org.openhab.binding.nuki.internal.dto.BridgeApiLockStateRequestDto;
  34 import org.openhab.binding.nuki.internal.dto.NukiHttpServerStatusResponseDto;
  35 import org.openhab.binding.nuki.internal.handler.AbstractNukiDeviceHandler;
  36 import org.openhab.binding.nuki.internal.handler.NukiBridgeHandler;
  37 import org.openhab.core.thing.Thing;
  38 import org.osgi.service.http.HttpService;
  39 import org.osgi.service.http.NamespaceException;
  40 import org.slf4j.Logger;
  41 import org.slf4j.LoggerFactory;
  42
  43 import com.google.gson.Gson;
  44
  45 /**
  46  * The {@link NukiApiServlet} class is responsible for handling the callbacks from the Nuki Bridge.
  47  *
  48  * @author Markus Katter - Initial contribution
  49  * @author Christian Hoefler - Door sensor integration
  50  * @author Jan Vybíral - Added Opener support, improved callback handling
  51  */
  52 @NonNullByDefault
  53 public class NukiApiServlet extends HttpServlet {
  54
  55     private final Logger logger = LoggerFactory.getLogger(NukiApiServlet.class);
  56     private static final long serialVersionUID = -3601163473320027239L;
  57     private static final String APPLICATION_JSON = "application/json";
  58
  59     private final HttpService httpService;
  60     private final List<NukiBridgeHandler> nukiBridgeHandlers = new ArrayList<>();
  61     private final Gson gson;
  62
  63     public NukiApiServlet(HttpService httpService) {
  64         this.httpService = httpService;
  65         gson = new Gson();
  66     }
  67
  68     public void add(NukiBridgeHandler nukiBridgeHandler) {
  69         logger.trace("Adding NukiBridgeHandler[{}] for Bridge[{}] to NukiApiServlet.",
  70                 nukiBridgeHandler.getThing().getUID(),
  71                 nukiBridgeHandler.getThing().getConfiguration().get(NukiBindingConstants.CONFIG_IP));
  72         if (nukiBridgeHandlers.isEmpty()) {
  73             this.activate();
  74         }
  75         nukiBridgeHandlers.add(nukiBridgeHandler);
  76     }
  77
  78     public void remove(NukiBridgeHandler nukiBridgeHandler) {
  79         logger.trace("Removing NukiBridgeHandler[{}] for Bridge[{}] from NukiApiServlet.",
  80                 nukiBridgeHandler.getThing().getUID(),
  81                 nukiBridgeHandler.getThing().getConfiguration().get(NukiBindingConstants.CONFIG_IP));
  82         nukiBridgeHandlers.remove(nukiBridgeHandler);
  83         if (nukiBridgeHandlers.isEmpty()) {
  84             this.deactivate();
  85         }
  86     }
  87
  88     private void activate() {
  89         Dictionary<String, String> servletParams = new Hashtable<>();
  90         try {
  91             httpService.registerServlet(NukiLinkBuilder.CALLBACK_ENDPOINT, this, servletParams,
  92                     httpService.createDefaultHttpContext());
  93             logger.debug("Started NukiApiServlet at path[{}]", NukiLinkBuilder.CALLBACK_ENDPOINT);
  94         } catch (ServletException | NamespaceException e) {
  95             logger.error("Error activating NukiApiServlet: {}", e.getMessage(), e);
  96         }
  97     }
  98
  99     private void deactivate() {
 100         httpService.unregister(NukiLinkBuilder.CALLBACK_ENDPOINT);
 101     }
 102
 103     @Override
 104     protected void service(HttpServletRequest request, HttpServletResponse response) throws IOException {
 105         logger.debug("Servlet Request at URI[{}] request[{}]", request.getRequestURI(), request);
 106         BridgeApiLockStateRequestDto bridgeApiLockStateRequestDto = getBridgeApiLockStateRequestDto(request);
 107
 108         ResponseEntity responseEntity;
 109         if (bridgeApiLockStateRequestDto == null) {
 110             logger.warn(
 111                     "Could not handle Bridge CallBack Request, Please report a bug, if this request was done by the Nuki Bridge! - {}",
 112                     request);
 113
 114             responseEntity = new ResponseEntity(HttpStatus.BAD_REQUEST_400,
 115                     new NukiHttpServerStatusResponseDto("Invalid BCB-Request!"));
 116         } else {
 117             try {
 118                 responseEntity = doHandle(bridgeApiLockStateRequestDto);
 119             } catch (Exception e) {
 120                 logger.warn("Error processing request '{}'", gson.toJson(bridgeApiLockStateRequestDto), e);
 121                 throw e;
 122             }
 123         }
 124
 125         setHeaders(response);
 126         response.setStatus(responseEntity.getStatus());
 127         response.getWriter().write(gson.toJson(responseEntity.getData()));
 128     }
 129
 130     private ResponseEntity doHandle(BridgeApiLockStateRequestDto request) {
 131         String nukiId = request.getNukiId().toString();
 132         for (NukiBridgeHandler nukiBridgeHandler : nukiBridgeHandlers) {
 133             logger.trace("Searching Bridge[{}] with NukiBridgeHandler[{}] for nukiId[{}].",
 134                     nukiBridgeHandler.getThing().getConfiguration().get(NukiBindingConstants.CONFIG_IP),
 135                     nukiBridgeHandler.getThing().getUID(), nukiId);
 136             List<Thing> allSmartLocks = nukiBridgeHandler.getThing().getThings();
 137             for (Thing thing : allSmartLocks) {
 138                 String nukiIdThing = String
 139                         .valueOf(thing.getConfiguration().get(NukiBindingConstants.PROPERTY_NUKI_ID));
 140                 if (nukiIdThing.equals(nukiId)) {
 141                     logger.debug("Processing ThingUID[{}] - nukiId[{}]", thing.getUID(), nukiId);
 142                     AbstractNukiDeviceHandler<?> nsh = getDeviceHandler(thing);
 143                     if (nsh != null) {
 144                         nsh.refreshState(request);
 145                         return new ResponseEntity(HttpStatus.OK_200, new NukiHttpServerStatusResponseDto("OK"));
 146                     }
 147                 }
 148             }
 149         }
 150
 151         logger.debug("Smart Lock with nukiId[{}] not found!", nukiId);
 152         return new ResponseEntity(HttpStatus.NOT_FOUND_404,
 153                 new NukiHttpServerStatusResponseDto("Smart Lock not found!"));
 154     }
 155
 156     private @Nullable BridgeApiLockStateRequestDto getBridgeApiLockStateRequestDto(HttpServletRequest request) {
 157         String requestContent = null;
 158         try (BufferedReader reader = request.getReader()) {
 159             requestContent = readAll(reader);
 160             BridgeApiLockStateRequestDto bridgeApiLockStateRequestDto = gson.fromJson(requestContent,
 161                     BridgeApiLockStateRequestDto.class);
 162             if (bridgeApiLockStateRequestDto != null && bridgeApiLockStateRequestDto.getNukiId() != null) {
 163                 logger.trace("requestContent[{}]", requestContent);
 164                 return bridgeApiLockStateRequestDto;
 165             } else {
 166                 logger.debug("Invalid BCB-Request payload data! {}", requestContent);
 167             }
 168         } catch (IOException e) {
 169             logger.debug("Could not read payload from BCB-Request! Message[{}]", e.getMessage());
 170         } catch (Exception e) {
 171             logger.error("Could not create BridgeApiLockStateRequestDto from BCB-Request! Message[{}]", e.getMessage());
 172             logger.error("requestContent[{}]", requestContent);
 173         }
 174         return null;
 175     }
 176
 177     private String readAll(BufferedReader reader) throws IOException {
 178         StringBuilder sb = new StringBuilder();
 179         char[] buffer = new char[1024];
 180         int read = 0;
 181         while ((read = reader.read(buffer)) != -1) {
 182             sb.append(buffer, 0, read);
 183         }
 184         return sb.toString();
 185     }
 186
 187     private @Nullable AbstractNukiDeviceHandler<?> getDeviceHandler(Thing thing) {
 188         AbstractNukiDeviceHandler<?> nsh = (AbstractNukiDeviceHandler<?>) thing.getHandler();
 189         if (nsh == null) {
 190             logger.debug("Could not get AbstractNukiDeviceHandler for ThingUID[{}]!", thing.getUID());
 191             return null;
 192         }
 193         return nsh;
 194     }
 195
 196     private void setHeaders(HttpServletResponse response) {
 197         response.setCharacterEncoding(StandardCharsets.UTF_8.name());
 198         response.setContentType(APPLICATION_JSON);
 199     }
 200
 201     private static class ResponseEntity {
 202         private final int status;
 203         private final Object data;
 204
 205         private ResponseEntity(int status, Object data) {
 206             this.status = status;
 207             this.data = data;
 208         }
 209
 210         public int getStatus() {
 211             return status;
 212         }
 213
 214         public Object getData() {
 215             return data;
 216         }
 217     }
 218 }