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.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  * @contributer Christian Hoefler - Door sensor integration
  50  * @contributer 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             responseEntity = doHandle(bridgeApiLockStateRequestDto, request.getParameter("bridgeId"));
 118         }
 119
 120         setHeaders(response);
 121         response.setStatus(responseEntity.getStatus());
 122         response.getWriter().write(gson.toJson(responseEntity.getData()));
 123     }
 124
 125     private ResponseEntity doHandle(BridgeApiLockStateRequestDto request, @Nullable String bridgeId) {
 126         String nukiId = request.getNukiId().toString();
 127         for (NukiBridgeHandler nukiBridgeHandler : nukiBridgeHandlers) {
 128             logger.trace("Searching Bridge[{}] with NukiBridgeHandler[{}] for nukiId[{}].",
 129                     nukiBridgeHandler.getThing().getConfiguration().get(NukiBindingConstants.CONFIG_IP),
 130                     nukiBridgeHandler.getThing().getUID(), nukiId);
 131             List<Thing> allSmartLocks = nukiBridgeHandler.getThing().getThings();
 132             for (Thing thing : allSmartLocks) {
 133                 String nukiIdThing = String
 134                         .valueOf(thing.getConfiguration().get(NukiBindingConstants.PROPERTY_NUKI_ID));
 135                 if (nukiIdThing.equals(nukiId)) {
 136                     logger.debug("Processing ThingUID[{}] - nukiId[{}]", thing.getUID(), nukiId);
 137                     AbstractNukiDeviceHandler<?> nsh = getDeviceHandler(thing);
 138                     if (nsh != null) {
 139                         nsh.refreshState(request);
 140                         return new ResponseEntity(HttpStatus.OK_200, new NukiHttpServerStatusResponseDto("OK"));
 141                     }
 142                 }
 143             }
 144         }
 145
 146         logger.debug("Smart Lock with nukiId[{}] not found!", nukiId);
 147         return new ResponseEntity(HttpStatus.NOT_FOUND_404,
 148                 new NukiHttpServerStatusResponseDto("Smart Lock not found!"));
 149     }
 150
 151     private @Nullable BridgeApiLockStateRequestDto getBridgeApiLockStateRequestDto(HttpServletRequest request) {
 152         String requestContent = null;
 153         try (BufferedReader reader = request.getReader()) {
 154             requestContent = readAll(reader);
 155             BridgeApiLockStateRequestDto bridgeApiLockStateRequestDto = gson.fromJson(requestContent,
 156                     BridgeApiLockStateRequestDto.class);
 157             if (bridgeApiLockStateRequestDto != null && bridgeApiLockStateRequestDto.getNukiId() != null) {
 158                 logger.trace("requestContent[{}]", requestContent);
 159                 return bridgeApiLockStateRequestDto;
 160             } else {
 161                 logger.debug("Invalid BCB-Request payload data! {}", requestContent);
 162             }
 163         } catch (IOException e) {
 164             logger.debug("Could not read payload from BCB-Request! Message[{}]", e.getMessage());
 165         } catch (Exception e) {
 166             logger.error("Could not create BridgeApiLockStateRequestDto from BCB-Request! Message[{}]", e.getMessage());
 167             logger.error("requestContent[{}]", requestContent);
 168         }
 169         return null;
 170     }
 171
 172     private String readAll(BufferedReader reader) throws IOException {
 173         StringBuilder sb = new StringBuilder();
 174         char[] buffer = new char[1024];
 175         int read = 0;
 176         while ((read = reader.read(buffer)) != -1) {
 177             sb.append(buffer, 0, read);
 178         }
 179         return sb.toString();
 180     }
 181
 182     private @Nullable AbstractNukiDeviceHandler<?> getDeviceHandler(Thing thing) {
 183         AbstractNukiDeviceHandler<?> nsh = (AbstractNukiDeviceHandler<?>) thing.getHandler();
 184         if (nsh == null) {
 185             logger.debug("Could not get AbstractNukiDeviceHandler for ThingUID[{}]!", thing.getUID());
 186             return null;
 187         }
 188         return nsh;
 189     }
 190
 191     private void setHeaders(HttpServletResponse response) {
 192         response.setCharacterEncoding(StandardCharsets.UTF_8.name());
 193         response.setContentType(APPLICATION_JSON);
 194     }
 195
 196     private static class ResponseEntity {
 197         private final int status;
 198         private final Object data;
 199
 200         private ResponseEntity(int status, Object data) {
 201             this.status = status;
 202             this.data = data;
 203         }
 204
 205         public int getStatus() {
 206             return status;
 207         }
 208
 209         public Object getData() {
 210             return data;
 211         }
 212     }
 213 }