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.myq.internal.handler;
  14
  15 import static org.openhab.binding.myq.internal.MyQBindingConstants.*;
  16
  17 import java.io.IOException;
  18 import java.net.CookieStore;
  19 import java.net.HttpCookie;
  20 import java.net.URI;
  21 import java.net.URISyntaxException;
  22 import java.nio.charset.StandardCharsets;
  23 import java.security.MessageDigest;
  24 import java.security.NoSuchAlgorithmException;
  25 import java.security.SecureRandom;
  26 import java.util.ArrayList;
  27 import java.util.Arrays;
  28 import java.util.Base64;
  29 import java.util.Collection;
  30 import java.util.Collections;
  31 import java.util.List;
  32 import java.util.Map;
  33 import java.util.Random;
  34 import java.util.concurrent.CompletableFuture;
  35 import java.util.concurrent.ExecutionException;
  36 import java.util.concurrent.Future;
  37 import java.util.concurrent.TimeUnit;
  38 import java.util.concurrent.TimeoutException;
  39 import java.util.stream.Collectors;
  40
  41 import org.eclipse.jdt.annotation.NonNullByDefault;
  42 import org.eclipse.jdt.annotation.Nullable;
  43 import org.eclipse.jetty.client.HttpClient;
  44 import org.eclipse.jetty.client.HttpContentResponse;
  45 import org.eclipse.jetty.client.api.ContentProvider;
  46 import org.eclipse.jetty.client.api.ContentResponse;
  47 import org.eclipse.jetty.client.api.Request;
  48 import org.eclipse.jetty.client.api.Response;
  49 import org.eclipse.jetty.client.api.Result;
  50 import org.eclipse.jetty.client.util.BufferingResponseListener;
  51 import org.eclipse.jetty.client.util.FormContentProvider;
  52 import org.eclipse.jetty.http.HttpMethod;
  53 import org.eclipse.jetty.http.HttpStatus;
  54 import org.eclipse.jetty.util.Fields;
  55 import org.jsoup.Jsoup;
  56 import org.jsoup.nodes.Document;
  57 import org.jsoup.nodes.Element;
  58 import org.openhab.binding.myq.internal.MyQDiscoveryService;
  59 import org.openhab.binding.myq.internal.config.MyQAccountConfiguration;
  60 import org.openhab.binding.myq.internal.dto.AccountDTO;
  61 import org.openhab.binding.myq.internal.dto.AccountsDTO;
  62 import org.openhab.binding.myq.internal.dto.DeviceDTO;
  63 import org.openhab.binding.myq.internal.dto.DevicesDTO;
  64 import org.openhab.core.auth.client.oauth2.AccessTokenRefreshListener;
  65 import org.openhab.core.auth.client.oauth2.AccessTokenResponse;
  66 import org.openhab.core.auth.client.oauth2.OAuthClientService;
  67 import org.openhab.core.auth.client.oauth2.OAuthException;
  68 import org.openhab.core.auth.client.oauth2.OAuthFactory;
  69 import org.openhab.core.auth.client.oauth2.OAuthResponseException;
  70 import org.openhab.core.thing.Bridge;
  71 import org.openhab.core.thing.ChannelUID;
  72 import org.openhab.core.thing.Thing;
  73 import org.openhab.core.thing.ThingStatus;
  74 import org.openhab.core.thing.ThingStatusDetail;
  75 import org.openhab.core.thing.ThingTypeUID;
  76 import org.openhab.core.thing.binding.BaseBridgeHandler;
  77 import org.openhab.core.thing.binding.ThingHandler;
  78 import org.openhab.core.thing.binding.ThingHandlerService;
  79 import org.openhab.core.types.Command;
  80 import org.slf4j.Logger;
  81 import org.slf4j.LoggerFactory;
  82
  83 import com.google.gson.FieldNamingPolicy;
  84 import com.google.gson.Gson;
  85 import com.google.gson.GsonBuilder;
  86 import com.google.gson.JsonSyntaxException;
  87
  88 /**
  89  * The {@link MyQAccountHandler} is responsible for communicating with the MyQ API based on an account.
  90  *
  91  * @author Dan Cunningham - Initial contribution
  92  */
  93 @NonNullByDefault
  94 public class MyQAccountHandler extends BaseBridgeHandler implements AccessTokenRefreshListener {
  95     /*
  96      * MyQ oAuth relate fields
  97      */
  98     private static final String CLIENT_SECRET = "VUQ0RFhuS3lQV3EyNUJTdw==";
  99     private static final String CLIENT_ID = "IOS_CGI_MYQ";
 100     private static final String REDIRECT_URI = "com.myqops://ios";
 101     private static final String SCOPE = "MyQ_Residential offline_access";
 102     /*
 103      * MyQ authentication API endpoints
 104      */
 105     private static final String LOGIN_BASE_URL = "https://partner-identity.myq-cloud.com";
 106     private static final String LOGIN_AUTHORIZE_URL = LOGIN_BASE_URL + "/connect/authorize";
 107     private static final String LOGIN_TOKEN_URL = LOGIN_BASE_URL + "/connect/token";
 108     // this should never happen, but lets be safe and give up after so many redirects
 109     private static final int LOGIN_MAX_REDIRECTS = 30;
 110     /*
 111      * MyQ device and account API endpoints
 112      */
 113     private static final String ACCOUNTS_URL = "https://accounts.myq-cloud.com/api/v6.0/accounts";
 114     private static final String DEVICES_URL = "https://devices.myq-cloud.com/api/v5.2/Accounts/%s/Devices";
 115     private static final String CMD_LAMP_URL = "https://account-devices-lamp.myq-cloud.com/api/v5.2/Accounts/%s/lamps/%s/%s";
 116     private static final String CMD_DOOR_URL = "https://account-devices-gdo.myq-cloud.com/api/v5.2/Accounts/%s/door_openers/%s/%s";
 117
 118     private static final Integer RAPID_REFRESH_SECONDS = 5;
 119     private final Logger logger = LoggerFactory.getLogger(MyQAccountHandler.class);
 120     private final Gson gsonLowerCase = new GsonBuilder()
 121             .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES).create();
 122     private final OAuthFactory oAuthFactory;
 123     private @Nullable Future<?> normalPollFuture;
 124     private @Nullable Future<?> rapidPollFuture;
 125     private @Nullable AccountsDTO accounts;
 126
 127     private List<DeviceDTO> devicesCache = new ArrayList<DeviceDTO>();
 128     private @Nullable OAuthClientService oAuthService;
 129     private Integer normalRefreshSeconds = 60;
 130     private HttpClient httpClient;
 131     private String username = "";
 132     private String password = "";
 133     private String userAgent = "";
 134     // force login, even if we have a token
 135     private boolean needsLogin = false;
 136
 137     public MyQAccountHandler(Bridge bridge, HttpClient httpClient, final OAuthFactory oAuthFactory) {
 138         super(bridge);
 139         this.httpClient = httpClient;
 140         this.oAuthFactory = oAuthFactory;
 141     }
 142
 143     @Override
 144     public void handleCommand(ChannelUID channelUID, Command command) {
 145     }
 146
 147     @Override
 148     public void initialize() {
 149         MyQAccountConfiguration config = getConfigAs(MyQAccountConfiguration.class);
 150         normalRefreshSeconds = config.refreshInterval;
 151         username = config.username;
 152         password = config.password;
 153         // MyQ can get picky about blocking user agents apparently
 154         userAgent = MyQAccountHandler.randomString(20);
 155         needsLogin = true;
 156         updateStatus(ThingStatus.UNKNOWN);
 157         restartPolls(false);
 158     }
 159
 160     @Override
 161     public void dispose() {
 162         stopPolls();
 163         OAuthClientService oAuthService = this.oAuthService;
 164         if (oAuthService != null) {
 165             oAuthService.close();
 166         }
 167     }
 168
 169     @Override
 170     public Collection<Class<? extends ThingHandlerService>> getServices() {
 171         return Collections.singleton(MyQDiscoveryService.class);
 172     }
 173
 174     @Override
 175     public void childHandlerInitialized(ThingHandler childHandler, Thing childThing) {
 176         List<DeviceDTO> localDeviceCaches = devicesCache;
 177         if (childHandler instanceof MyQDeviceHandler) {
 178             MyQDeviceHandler handler = (MyQDeviceHandler) childHandler;
 179             localDeviceCaches.stream()
 180                     .filter(d -> ((MyQDeviceHandler) childHandler).getSerialNumber().equalsIgnoreCase(d.serialNumber))
 181                     .findFirst().ifPresent(handler::handleDeviceUpdate);
 182         }
 183     }
 184
 185     @Override
 186     public void onAccessTokenResponse(AccessTokenResponse tokenResponse) {
 187         logger.debug("Auth Token Refreshed, expires in {}", tokenResponse.getExpiresIn());
 188     }
 189
 190     /**
 191      * Sends a door action to the MyQ API
 192      *
 193      * @param device
 194      * @param action
 195      */
 196     public void sendDoorAction(DeviceDTO device, String action) {
 197         sendAction(device, action, CMD_DOOR_URL);
 198     }
 199
 200     /**
 201      * Sends a lamp action to the MyQ API
 202      *
 203      * @param device
 204      * @param action
 205      */
 206     public void sendLampAction(DeviceDTO device, String action) {
 207         sendAction(device, action, CMD_LAMP_URL);
 208     }
 209
 210     private void sendAction(DeviceDTO device, String action, String urlFormat) {
 211         if (getThing().getStatus() != ThingStatus.ONLINE) {
 212             logger.debug("Account offline, ignoring action {}", action);
 213             return;
 214         }
 215
 216         try {
 217             ContentResponse response = sendRequest(
 218                     String.format(urlFormat, device.accountId, device.serialNumber, action), HttpMethod.PUT, null,
 219                     null);
 220             if (HttpStatus.isSuccess(response.getStatus())) {
 221                 restartPolls(true);
 222             } else {
 223                 logger.debug("Failed to send action {} : {}", action, response.getContentAsString());
 224             }
 225         } catch (InterruptedException | MyQCommunicationException | MyQAuthenticationException e) {
 226             logger.debug("Could not send action", e);
 227         }
 228     }
 229
 230     /**
 231      * Last known state of MyQ Devices
 232      *
 233      * @return cached MyQ devices
 234      */
 235     public @Nullable List<DeviceDTO> devicesCache() {
 236         return devicesCache;
 237     }
 238
 239     private void stopPolls() {
 240         stopNormalPoll();
 241         stopRapidPoll();
 242     }
 243
 244     private synchronized void stopNormalPoll() {
 245         stopFuture(normalPollFuture);
 246         normalPollFuture = null;
 247     }
 248
 249     private synchronized void stopRapidPoll() {
 250         stopFuture(rapidPollFuture);
 251         rapidPollFuture = null;
 252     }
 253
 254     private void stopFuture(@Nullable Future<?> future) {
 255         if (future != null) {
 256             future.cancel(true);
 257         }
 258     }
 259
 260     private synchronized void restartPolls(boolean rapid) {
 261         stopPolls();
 262         if (rapid) {
 263             normalPollFuture = scheduler.scheduleWithFixedDelay(this::normalPoll, 35, normalRefreshSeconds,
 264                     TimeUnit.SECONDS);
 265             rapidPollFuture = scheduler.scheduleWithFixedDelay(this::rapidPoll, 3, RAPID_REFRESH_SECONDS,
 266                     TimeUnit.SECONDS);
 267         } else {
 268             normalPollFuture = scheduler.scheduleWithFixedDelay(this::normalPoll, 0, normalRefreshSeconds,
 269                     TimeUnit.SECONDS);
 270         }
 271     }
 272
 273     private void normalPoll() {
 274         stopRapidPoll();
 275         fetchData();
 276     }
 277
 278     private void rapidPoll() {
 279         fetchData();
 280     }
 281
 282     private synchronized void fetchData() {
 283         try {
 284             if (accounts == null) {
 285                 getAccounts();
 286             }
 287             getDevices();
 288         } catch (MyQCommunicationException e) {
 289             logger.debug("MyQ communication error", e);
 290             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.COMMUNICATION_ERROR, e.getMessage());
 291         } catch (MyQAuthenticationException e) {
 292             logger.debug("MyQ authentication error", e);
 293             updateStatus(ThingStatus.OFFLINE, ThingStatusDetail.CONFIGURATION_ERROR, e.getMessage());
 294             stopPolls();
 295         } catch (InterruptedException e) {
 296             // we were shut down, ignore
 297         }
 298     }
 299
 300     /**
 301      * This attempts to navigate the MyQ oAuth login flow in order to obtain a @AccessTokenResponse
 302      *
 303      * @return AccessTokenResponse token
 304      * @throws InterruptedException
 305      * @throws MyQCommunicationException
 306      * @throws MyQAuthenticationException
 307      */
 308     private AccessTokenResponse login()
 309             throws InterruptedException, MyQCommunicationException, MyQAuthenticationException {
 310         try {
 311             // make sure we have a fresh session
 312             URI authUri = new URI(LOGIN_BASE_URL);
 313             CookieStore store = httpClient.getCookieStore();
 314             store.get(authUri).forEach(cookie -> {
 315                 store.remove(authUri, cookie);
 316             });
 317
 318             String codeVerifier = generateCodeVerifier();
 319
 320             ContentResponse loginPageResponse = getLoginPage(codeVerifier);
 321
 322             // load the login page to get cookies and form parameters
 323             Document loginPage = Jsoup.parse(loginPageResponse.getContentAsString());
 324             Element form = loginPage.select("form").first();
 325             Element requestToken = loginPage.select("input[name=__RequestVerificationToken]").first();
 326             Element returnURL = loginPage.select("input[name=ReturnUrl]").first();
 327
 328             if (form == null || requestToken == null) {
 329                 throw new MyQCommunicationException("Could not load login page");
 330             }
 331
 332             // url that the form will submit to
 333             String action = LOGIN_BASE_URL + form.attr("action");
 334
 335             // post our user name and password along with elements from the scraped form
 336             String location = postLogin(action, requestToken.attr("value"), returnURL.attr("value"));
 337             if (location == null) {
 338                 throw new MyQAuthenticationException("Could not login with credentials");
 339             }
 340
 341             // finally complete the oAuth flow and retrieve a JSON oAuth token response
 342             ContentResponse tokenResponse = getLoginToken(location, codeVerifier);
 343             String loginToken = tokenResponse.getContentAsString();
 344
 345             try {
 346                 AccessTokenResponse accessTokenResponse = gsonLowerCase.fromJson(loginToken, AccessTokenResponse.class);
 347                 if (accessTokenResponse == null) {
 348                     throw new MyQAuthenticationException("Could not parse token response");
 349                 }
 350                 getOAuthService().importAccessTokenResponse(accessTokenResponse);
 351                 return accessTokenResponse;
 352             } catch (JsonSyntaxException e) {
 353                 throw new MyQCommunicationException("Invalid Token Response " + loginToken);
 354             }
 355         } catch (IOException | ExecutionException | TimeoutException | OAuthException | URISyntaxException e) {
 356             throw new MyQCommunicationException(e.getMessage());
 357         }
 358     }
 359
 360     private void getAccounts() throws InterruptedException, MyQCommunicationException, MyQAuthenticationException {
 361         ContentResponse response = sendRequest(ACCOUNTS_URL, HttpMethod.GET, null, null);
 362         accounts = parseResultAndUpdateStatus(response, gsonLowerCase, AccountsDTO.class);
 363     }
 364
 365     private void getDevices() throws InterruptedException, MyQCommunicationException, MyQAuthenticationException {
 366         AccountsDTO localAccounts = accounts;
 367         if (localAccounts == null) {
 368             return;
 369         }
 370
 371         List<DeviceDTO> currentDevices = new ArrayList<DeviceDTO>();
 372
 373         for (AccountDTO account : localAccounts.accounts) {
 374             ContentResponse response = sendRequest(String.format(DEVICES_URL, account.id), HttpMethod.GET, null, null);
 375             DevicesDTO devices = parseResultAndUpdateStatus(response, gsonLowerCase, DevicesDTO.class);
 376             currentDevices.addAll(devices.items);
 377             devices.items.forEach(device -> {
 378                 ThingTypeUID thingTypeUID = new ThingTypeUID(BINDING_ID, device.deviceFamily);
 379                 if (SUPPORTED_DISCOVERY_THING_TYPES_UIDS.contains(thingTypeUID)) {
 380                     for (Thing thing : getThing().getThings()) {
 381                         ThingHandler handler = thing.getHandler();
 382                         if (handler != null && ((MyQDeviceHandler) handler).getSerialNumber()
 383                                 .equalsIgnoreCase(device.serialNumber)) {
 384                             ((MyQDeviceHandler) handler).handleDeviceUpdate(device);
 385                         }
 386                     }
 387                 }
 388             });
 389         }
 390         devicesCache = currentDevices;
 391     }
 392
 393     private synchronized ContentResponse sendRequest(String url, HttpMethod method, @Nullable ContentProvider content,
 394             @Nullable String contentType)
 395             throws InterruptedException, MyQCommunicationException, MyQAuthenticationException {
 396         AccessTokenResponse tokenResponse = null;
 397         // if we don't need to force a login, attempt to use the token we have
 398         if (!needsLogin) {
 399             try {
 400                 tokenResponse = getOAuthService().getAccessTokenResponse();
 401             } catch (OAuthException | IOException | OAuthResponseException e) {
 402                 // ignore error, will try to login below
 403                 logger.debug("Error accessing token, will attempt to login again", e);
 404             }
 405         }
 406
 407         // if no token, or we need to login, do so now
 408         if (tokenResponse == null) {
 409             tokenResponse = login();
 410             needsLogin = false;
 411         }
 412
 413         Request request = httpClient.newRequest(url).method(method).agent(userAgent).timeout(10, TimeUnit.SECONDS)
 414                 .header("Authorization", authTokenHeader(tokenResponse));
 415         if (content != null & contentType != null) {
 416             request = request.content(content, contentType);
 417         }
 418
 419         // use asyc jetty as the API service will response with a 401 error when credentials are wrong,
 420         // but not a WWW-Authenticate header which causes Jetty to throw a generic execution exception which
 421         // prevents us from knowing the response code
 422         logger.trace("Sending {} to {}", request.getMethod(), request.getURI());
 423         final CompletableFuture<ContentResponse> futureResult = new CompletableFuture<>();
 424         request.send(new BufferingResponseListener() {
 425             @NonNullByDefault({})
 426             @Override
 427             public void onComplete(Result result) {
 428                 Response response = result.getResponse();
 429                 futureResult.complete(new HttpContentResponse(response, getContent(), getMediaType(), getEncoding()));
 430             }
 431         });
 432
 433         try {
 434             ContentResponse result = futureResult.get();
 435             logger.trace("Account Response - status: {} content: {}", result.getStatus(), result.getContentAsString());
 436             return result;
 437         } catch (ExecutionException e) {
 438             throw new MyQCommunicationException(e.getMessage());
 439         }
 440     }
 441
 442     private <T> T parseResultAndUpdateStatus(ContentResponse response, Gson parser, Class<T> classOfT)
 443             throws MyQCommunicationException {
 444         if (HttpStatus.isSuccess(response.getStatus())) {
 445             try {
 446                 T responseObject = parser.fromJson(response.getContentAsString(), classOfT);
 447                 if (responseObject != null) {
 448                     if (getThing().getStatus() != ThingStatus.ONLINE) {
 449                         updateStatus(ThingStatus.ONLINE);
 450                     }
 451                     return responseObject;
 452                 } else {
 453                     throw new MyQCommunicationException("Bad response from server");
 454                 }
 455             } catch (JsonSyntaxException e) {
 456                 throw new MyQCommunicationException("Invalid JSON Response " + response.getContentAsString());
 457             }
 458         } else if (response.getStatus() == HttpStatus.UNAUTHORIZED_401) {
 459             // our tokens no longer work, will need to login again
 460             needsLogin = true;
 461             throw new MyQCommunicationException("Token was rejected for request");
 462         } else {
 463             throw new MyQCommunicationException(
 464                     "Invalid Response Code " + response.getStatus() + " : " + response.getContentAsString());
 465         }
 466     }
 467
 468     /**
 469      * Returns the MyQ login page which contains form elements and cookies needed to login
 470      *
 471      * @param codeVerifier
 472      * @return
 473      * @throws InterruptedException
 474      * @throws ExecutionException
 475      * @throws TimeoutException
 476      */
 477     private ContentResponse getLoginPage(String codeVerifier)
 478             throws InterruptedException, ExecutionException, TimeoutException {
 479         try {
 480             Request request = httpClient.newRequest(LOGIN_AUTHORIZE_URL) //
 481                     .param("client_id", CLIENT_ID) //
 482                     .param("code_challenge", generateCodeChallange(codeVerifier)) //
 483                     .param("code_challenge_method", "S256") //
 484                     .param("redirect_uri", REDIRECT_URI) //
 485                     .param("response_type", "code") //
 486                     .param("scope", SCOPE) //
 487                     .agent(userAgent).followRedirects(true);
 488             logger.debug("Sending {} to {}", request.getMethod(), request.getURI());
 489             ContentResponse response = request.send();
 490             logger.debug("Login Code {} Response {}", response.getStatus(), response.getContentAsString());
 491             return response;
 492         } catch (NoSuchAlgorithmException e) {
 493             throw new ExecutionException(e.getCause());
 494         }
 495     }
 496
 497     /**
 498      * Sends configured credentials and elements from the login page in order to obtain a redirect location header value
 499      *
 500      * @param url
 501      * @param requestToken
 502      * @param returnURL
 503      * @return The location header value
 504      * @throws InterruptedException
 505      * @throws ExecutionException
 506      * @throws TimeoutException
 507      */
 508     @Nullable
 509     private String postLogin(String url, String requestToken, String returnURL)
 510             throws InterruptedException, ExecutionException, TimeoutException {
 511         /*
 512          * on a successful post to this page we will get several redirects, and a final 301 to:
 513          * com.myqops://ios?code=0123456789&scope=MyQ_Residential%20offline_access&iss=https%3A%2F%2Fpartner-identity.
 514          * myq-cloud.com
 515          *
 516          * We can then take the parameters out of this location and continue the process
 517          */
 518         Fields fields = new Fields();
 519         fields.add("Email", username);
 520         fields.add("Password", password);
 521         fields.add("__RequestVerificationToken", requestToken);
 522         fields.add("ReturnUrl", returnURL);
 523
 524         Request request = httpClient.newRequest(url).method(HttpMethod.POST) //
 525                 .content(new FormContentProvider(fields)) //
 526                 .agent(userAgent) //
 527                 .followRedirects(false);
 528         setCookies(request);
 529
 530         logger.debug("Posting Login to {}", url);
 531         ContentResponse response = request.send();
 532
 533         String location = null;
 534
 535         // follow redirects until we match our REDIRECT_URI or hit a redirect safety limit
 536         for (int i = 0; i < LOGIN_MAX_REDIRECTS && HttpStatus.isRedirection(response.getStatus()); i++) {
 537
 538             String loc = response.getHeaders().get("location");
 539             if (logger.isTraceEnabled()) {
 540                 logger.trace("Redirect Login: Code {} Location Header: {} Response {}", response.getStatus(), loc,
 541                         response.getContentAsString());
 542             }
 543             if (loc == null) {
 544                 logger.debug("No location value");
 545                 break;
 546             }
 547             if (loc.indexOf(REDIRECT_URI) == 0) {
 548                 location = loc;
 549                 break;
 550             }
 551             request = httpClient.newRequest(LOGIN_BASE_URL + loc).agent(userAgent).followRedirects(false);
 552             setCookies(request);
 553             response = request.send();
 554         }
 555         return location;
 556     }
 557
 558     /**
 559      * Final step of the login process to get an oAuth access response token
 560      *
 561      * @param redirectLocation
 562      * @param codeVerifier
 563      * @return
 564      * @throws InterruptedException
 565      * @throws ExecutionException
 566      * @throws TimeoutException
 567      */
 568     private ContentResponse getLoginToken(String redirectLocation, String codeVerifier)
 569             throws InterruptedException, ExecutionException, TimeoutException {
 570         try {
 571             Map<String, String> params = parseLocationQuery(redirectLocation);
 572
 573             Fields fields = new Fields();
 574             fields.add("client_id", CLIENT_ID);
 575             fields.add("client_secret", Base64.getEncoder().encodeToString(CLIENT_SECRET.getBytes()));
 576             fields.add("code", params.get("code"));
 577             fields.add("code_verifier", codeVerifier);
 578             fields.add("grant_type", "authorization_code");
 579             fields.add("redirect_uri", REDIRECT_URI);
 580             fields.add("scope", params.get("scope"));
 581
 582             Request request = httpClient.newRequest(LOGIN_TOKEN_URL) //
 583                     .content(new FormContentProvider(fields)) //
 584                     .method(HttpMethod.POST) //
 585                     .agent(userAgent).followRedirects(true);
 586             setCookies(request);
 587
 588             ContentResponse response = request.send();
 589             if (logger.isTraceEnabled()) {
 590                 logger.trace("Login Code {} Response {}", response.getStatus(), response.getContentAsString());
 591             }
 592             return response;
 593         } catch (URISyntaxException e) {
 594             throw new ExecutionException(e.getCause());
 595         }
 596     }
 597
 598     private OAuthClientService getOAuthService() {
 599         OAuthClientService oAuthService = this.oAuthService;
 600         if (oAuthService == null || oAuthService.isClosed()) {
 601             oAuthService = oAuthFactory.createOAuthClientService(getThing().toString(), LOGIN_TOKEN_URL,
 602                     LOGIN_AUTHORIZE_URL, CLIENT_ID, CLIENT_SECRET, SCOPE, false);
 603             oAuthService.addAccessTokenRefreshListener(this);
 604             this.oAuthService = oAuthService;
 605         }
 606         return oAuthService;
 607     }
 608
 609     private static String randomString(int length) {
 610         int low = 97; // a-z
 611         int high = 122; // A-Z
 612         StringBuilder sb = new StringBuilder(length);
 613         Random random = new Random();
 614         for (int i = 0; i < length; i++) {
 615             sb.append((char) (low + (int) (random.nextFloat() * (high - low + 1))));
 616         }
 617         return sb.toString();
 618     }
 619
 620     private String generateCodeVerifier() {
 621         SecureRandom secureRandom = new SecureRandom();
 622         byte[] codeVerifier = new byte[32];
 623         secureRandom.nextBytes(codeVerifier);
 624         return Base64.getUrlEncoder().withoutPadding().encodeToString(codeVerifier);
 625     }
 626
 627     private String generateCodeChallange(String codeVerifier) throws NoSuchAlgorithmException {
 628         byte[] bytes = codeVerifier.getBytes(StandardCharsets.US_ASCII);
 629         MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
 630         messageDigest.update(bytes, 0, bytes.length);
 631         byte[] digest = messageDigest.digest();
 632         return Base64.getUrlEncoder().withoutPadding().encodeToString(digest);
 633     }
 634
 635     private Map<String, String> parseLocationQuery(String location) throws URISyntaxException {
 636         URI uri = new URI(location);
 637         return Arrays.stream(uri.getQuery().split("&")).map(str -> str.split("="))
 638                 .collect(Collectors.toMap(str -> str[0], str -> str[1]));
 639     }
 640
 641     private void setCookies(Request request) {
 642         for (HttpCookie c : httpClient.getCookieStore().getCookies()) {
 643             request.cookie(c);
 644         }
 645     }
 646
 647     private String authTokenHeader(AccessTokenResponse tokenResponse) {
 648         return tokenResponse.getTokenType() + " " + tokenResponse.getAccessToken();
 649     }
 650
 651     /**
 652      * Exception for authenticated related errors
 653      */
 654     class MyQAuthenticationException extends Exception {
 655         private static final long serialVersionUID = 1L;
 656
 657         public MyQAuthenticationException(String message) {
 658             super(message);
 659         }
 660     }
 661
 662     /**
 663      * Generic exception for non authentication related errors when communicating with the MyQ service.
 664      */
 665     class MyQCommunicationException extends IOException {
 666         private static final long serialVersionUID = 1L;
 667
 668         public MyQCommunicationException(@Nullable String message) {
 669             super(message);
 670         }
 671     }
 672 }