private static String addParameters(Context context, String urlAsString) {
    String updatedUrlAsString = "";
    String spacer = "?";
    if (urlAsString.contains("?")) {
      spacer = "&";
    }

    // Currency settings
    String currency = CurrencyEnums.USD.getCurrency();

    if (StringUtils.equals(
        SDKSettings.getSharedPreferenceString(context, InternalConstants.KEY_PREF_CATALOG),
        CatalogEnums.APPARELUK.getCatalog())) {
      // TODO - not supported by the apparel-uk catalog
      currency = "";
    }

    updatedUrlAsString =
        urlAsString
            + spacer
            + "lang="
            + SDKSettings.getSharedPreferenceString(context, "web_services_language_preference")
            + "&curr="
            + currency;

    return updatedUrlAsString;
  }
  /**
   * Synchronous call for logging out
   *
   * @return The data from the server as a string, in almost all cases JSON
   * @throws MalformedURLException
   * @throws IOException
   * @throws JSONException
   */
  public static String getLogoutResponse(Context context)
      throws MalformedURLException, IOException, JSONException {
    // Refresh if necessary
    if (WebServiceAuthProvider.tokenExpiredHint(context)) {
      WebServiceAuthProvider.refreshAccessToken(context);
    }

    boolean refreshLimitReached = false;
    int refreshed = 0;

    String response = "";
    while (!refreshLimitReached) {
      // If we have refreshed max number of times, we will not do so again
      if (refreshed == 1) {
        refreshLimitReached = true;
      }

      URL url = new URL(urlForLogout(context));
      HttpsURLConnection connection = createSecureConnection(url);
      String authValue = "Bearer " + SDKSettings.getSharedPreferenceString(context, "access_token");

      connection.setRequestMethod("POST");
      connection.setRequestProperty("Authorization", authValue);
      connection.setDoOutput(true);
      connection.setDoInput(true);
      connection.connect();

      try {
        LoggingUtils.d(LOG_TAG, "LogoutResponse" + connection.toString());
        response = readFromStream(connection.getInputStream());
      } catch (MalformedURLException e) {
        LoggingUtils.e(
            LOG_TAG,
            "Error reading stream \""
                + connection.getInputStream()
                + "\". "
                + e.getLocalizedMessage(),
            null);
      } catch (IOException e) {
        response = readFromStream(connection.getErrorStream());
      } finally {
        connection.disconnect();
      }

      // Allow for calls to return nothing
      if (response.length() == 0) {
        return "";
      }

      // Check for JSON parsing errors (will throw JSONException is can't be parsed)
      JSONObject object = new JSONObject(response);

      // If no error, return response
      if (!object.has("error")) {
        return response;
      }
      // If there is a refresh token error, refresh the token
      else if (object.getString("error").equals("invalid_token")) {
        if (refreshLimitReached) {
          // Give up
          return response;
        } else {
          // Refresh the token
          WebServiceAuthProvider.refreshAccessToken(context);
          refreshed++;
        }
      }
    } // while(!refreshLimitReached)

    return response;
  }
  /**
   * Synchronous call to the OCC web services
   *
   * @param url The url
   * @param isAuthorizedRequest Whether this request requires the authorization token sending
   * @param httpMethod method type (GET, PUT, POST, DELETE)
   * @param httpBody Data to be sent in the body (Can be empty)
   * @return The data from the server as a string, in almost all cases JSON
   * @throws MalformedURLException
   * @throws IOException
   * @throws ProtocolException
   */
  public static String getResponse(
      Context context, String url, Boolean isAuthorizedRequest, String httpMethod, Bundle httpBody)
      throws MalformedURLException, IOException, ProtocolException, JSONException {
    // Refresh if necessary
    if (isAuthorizedRequest && WebServiceAuthProvider.tokenExpiredHint(context)) {
      WebServiceAuthProvider.refreshAccessToken(context);
    }

    boolean refreshLimitReached = false;
    int refreshed = 0;

    String response = "";
    while (!refreshLimitReached) {
      // If we have refreshed max number of times, we will not do so again
      if (refreshed == 1) {
        refreshLimitReached = true;
      }

      // Make the connection and get the response
      OutputStream os;
      HttpURLConnection connection;

      if (httpMethod.equals("GET") && httpBody != null && !httpBody.isEmpty()) {
        url = url + "?" + encodePostBody(httpBody);
      }
      URL requestURL = new URL(addParameters(context, url));

      if (StringUtils.equalsIgnoreCase(requestURL.getProtocol(), "https")) {
        HttpsURLConnection https = createSecureConnection(requestURL);
        if (isAuthorizedRequest) {
          String authValue =
              "Bearer " + SDKSettings.getSharedPreferenceString(context, "access_token");
          https.setRequestProperty("Authorization", authValue);
        }
        connection = https;
      } else {
        connection = createConnection(requestURL);
      }
      connection.setRequestMethod(httpMethod);

      if (!httpMethod.equals("GET") && !httpMethod.equals("DELETE")) {
        connection.setDoOutput(true);
        connection.setDoInput(true);
        connection.connect();

        if (httpBody != null && !httpBody.isEmpty()) {
          os = new BufferedOutputStream(connection.getOutputStream());
          os.write(encodePostBody(httpBody).getBytes());
          os.flush();
        }
      }

      response = "";
      try {
        LoggingUtils.d(LOG_TAG, connection.toString());
        response = readFromStream(connection.getInputStream());
      } catch (FileNotFoundException e) {
        LoggingUtils.e(
            LOG_TAG,
            "Error reading stream \""
                + connection.getInputStream()
                + "\". "
                + e.getLocalizedMessage(),
            context);
        response = readFromStream(connection.getErrorStream());
      } finally {
        connection.disconnect();
      }

      // Allow for calls to return nothing
      if (response.length() == 0) {
        return "";
      }

      // Check for JSON parsing errors (will throw JSONException is can't be parsed)
      JSONObject object = new JSONObject(response);

      // If no error, return response
      if (!object.has("error")) {
        return response;
      }
      // If there is a refresh token error, refresh the token
      else if (object.getString("error").equals("invalid_token")) {
        if (refreshLimitReached) {
          // Give up
          return response;
        } else {
          // Refresh the token
          WebServiceAuthProvider.refreshAccessToken(context);
          refreshed++;
        }
      }
    } // while(!refreshLimitReached)

    // There is an error other than a refresh error, so return the response
    return response;
  }
 private static String baseUrl(Context context) {
   return String.format(
       "%s/rest/v1",
       SDKSettings.getSharedPreferenceString(context, "web_services_base_url_preference"));
 }