/** Tests method getting/setting. */
 public void testMethod() throws Exception {
   final Request request = getRequest();
   request.setMethod(Method.GET);
   assertEquals(Method.GET, request.getMethod());
   request.setMethod(Method.POST);
   assertEquals(Method.POST, request.getMethod());
 }
Beispiel #2
0
  /**
   * Handles a call for a local entity. By default, only GET and HEAD methods are implemented.
   *
   * @param request The request to handle.
   * @param response The response to update.
   * @param decodedPath The URL decoded entity path.
   */
  @Override
  protected void handleLocal(Request request, Response response, String decodedPath) {
    int spi = decodedPath.indexOf("!/");
    String fileUri;
    String entryName;
    if (spi != -1) {
      fileUri = decodedPath.substring(0, spi);
      entryName = decodedPath.substring(spi + 2);
    } else {
      fileUri = decodedPath;
      entryName = "";
    }

    LocalReference fileRef = new LocalReference(fileUri);
    if (Protocol.FILE.equals(fileRef.getSchemeProtocol())) {
      final File file = fileRef.getFile();
      if (Method.GET.equals(request.getMethod()) || Method.HEAD.equals(request.getMethod())) {
        handleGet(request, response, file, entryName, getMetadataService());
      } else if (Method.PUT.equals(request.getMethod())) {
        handlePut(request, response, file, entryName);
      } else {
        response.setStatus(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED);
        response.getAllowedMethods().add(Method.GET);
        response.getAllowedMethods().add(Method.HEAD);
        response.getAllowedMethods().add(Method.PUT);
      }
    } else {
      response.setStatus(Status.SERVER_ERROR_NOT_IMPLEMENTED, "Only works on local files.");
    }
  }
Beispiel #3
0
          @Override
          public void handle(Request request, Response response) {

            String dbName = (String) request.getAttributes().get("dbname");
            String collection = (String) request.getAttributes().get("collection");

            if (request.getMethod() == Method.POST) {
              try {
                String query = request.getEntityAsText();
                System.out.println(query);
                TypeReference<Map<String, Object>> typeRef =
                    new TypeReference<Map<String, Object>>() {};
                Map<String, Object> map = null;
                try {
                  map = om.readValue(query, typeRef);
                } catch (Exception e) {
                  Logger.stderr(OBJECT_MAPPING_ERROR_MESSAGE + e);
                  return;
                }

                ObjectMapper om = new ObjectMapper();
                String r = null;
                try {
                  r = om.writeValueAsString(map);
                } catch (IOException e) {
                  e.printStackTrace();
                }

                storageInstance.insert(dbName, collection, (Map<String, Object>) map);
                response.setEntity(r, MediaType.APPLICATION_JSON);
              } catch (StorageException e) {
                Logger.stderr(INSERTING_ERROR_MESSAGE + e);
              }
            }
          }
Beispiel #4
0
  @Override
  protected int beforeHandle(Request request, Response response) {
    if (Method.OPTIONS.equals(request.getMethod())) {
      Series<Header> requestHeaders =
          (Series<Header>) request.getAttributes().get(HeaderConstants.ATTRIBUTE_HEADERS);
      String origin = requestHeaders.getFirstValue("Origin", false, "*");
      String rh = requestHeaders.getFirstValue("Access-Control-Request-Headers", false, "*");
      Series<Header> responseHeaders =
          (Series<Header>) response.getAttributes().get(HeaderConstants.ATTRIBUTE_HEADERS);
      if (responseHeaders == null) {
        responseHeaders = new Series<Header>(Header.class);
      }
      responseHeaders.add("Access-Control-Allow-Origin", origin);
      responseHeaders.set("Access-Control-Expose-Headers", "Authorization, Link");
      responseHeaders.add("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS");
      responseHeaders.add("Access-Control-Allow-Headers", rh);
      responseHeaders.add("Access-Control-Allow-Credentials", "true");
      responseHeaders.add("Access-Control-Max-Age", "60");
      response.getAttributes().put(HeaderConstants.ATTRIBUTE_HEADERS, responseHeaders);
      response.setEntity(new EmptyRepresentation());
      return SKIP;
    }

    return super.beforeHandle(request, response);
  }
Beispiel #5
0
          @Override
          public void handle(Request request, Response response) {
            if (request.getMethod() == Method.GET) {
              List<String> listDBs = null;
              String r = null;
              try {
                listDBs = storageInstance.retrieveDBs(); //
                Logger.stderr(listDBs.toString());
              } catch (StorageException e) {
                e.printStackTrace();
              }

              ObjectMapper om = new ObjectMapper();

              try {
                r = om.writeValueAsString(listDBs);
                response.setEntity(r, MediaType.APPLICATION_JSON);
              } catch (Exception e) {
                Logger.stderr(OBJECT_MAPPING_ERROR_MESSAGE + e);
                return;
              }

              response.setEntity(r, MediaType.APPLICATION_JSON);
            }
          }
  @Override
  protected int doHandle(Request request, Response response) {

    super.doHandle(request, response);

    if (response.getStatus().isSuccess() && request.getMethod().equals(Method.GET)) {
      boolean isHtml = false;
      for (Preference<MediaType> mt : request.getClientInfo().getAcceptedMediaTypes()) {
        if (mt.getMetadata().includes(MediaType.APPLICATION_XHTML)
            || mt.getMetadata().includes(MediaType.TEXT_HTML)) {
          isHtml = true;
          break;
        }
      }
      if (isHtml) {
        try {
          response.setEntity(toHtml(request, response));
        } catch (SlipStreamException e) {
          // ok it failed generating html... do we care?
        }
      }
    }

    return CONTINUE;
  }
  @Override
  protected int beforeHandle(Request request, Response response) {
    Cookie cookie = request.getCookies().getFirst("Credentials");

    if (cookie != null) {
      // Extract the challenge response from the cookie
      String[] credentials = cookie.getValue().split("=");

      if (credentials.length == 2) {
        String identifier = credentials[0];
        String secret = credentials[1];
        request.setChallengeResponse(
            new ChallengeResponse(ChallengeScheme.HTTP_COOKIE, identifier, secret));
      }
    } else if (Method.POST.equals(request.getMethod())
        && request.getResourceRef().getQueryAsForm().getFirst("login") != null) {
      // Intercepting a login form
      Form credentials = new Form(request.getEntity());
      String identifier = credentials.getFirstValue("identifier");
      String secret = credentials.getFirstValue("secret");
      request.setChallengeResponse(
          new ChallengeResponse(ChallengeScheme.HTTP_COOKIE, identifier, secret));

      // Continue call processing to return the target representation if
      // authentication is successful or a new login page
      request.setMethod(Method.GET);
    }

    return super.beforeHandle(request, response);
  }
Beispiel #8
0
          @Override
          public void handle(Request request, Response response) {

            String dbName = (String) request.getAttributes().get("dbname");
            String collection = (String) request.getAttributes().get("collection");

            if (request.getMethod() == Method.POST) {
              try {
                String query = request.getEntityAsText();
                System.out.println(query);
                TypeReference<Map<String, Object>> typeRef =
                    new TypeReference<Map<String, Object>>() {};
                Map<String, Object> map = null;
                try {
                  map = om.readValue(query, typeRef);
                } catch (Exception e) {
                  Logger.stderr(OBJECT_MAPPING_ERROR_MESSAGE + e);
                  return;
                }
                storageInstance.dropIndex(dbName, collection, map);
                response.setEntity(query, MediaType.APPLICATION_JSON);
              } catch (StorageException e) {
                Logger.stderr(DROP_INDEX_ERROR_MESSAGE + e);
              }
            }
          }
  /**
   * Formats the response digest.
   *
   * @param challengeResponse The challenge response.
   * @param request The request if available.
   * @return The formatted secret of a challenge response.
   */
  public char[] formatResponseDigest(ChallengeResponse challengeResponse, Request request) {
    String a1 = null;

    if (!Digest.ALGORITHM_HTTP_DIGEST.equals(challengeResponse.getSecretAlgorithm())) {
      if (!AuthenticatorUtils.anyNull(
          challengeResponse.getIdentifier(),
          challengeResponse.getSecret(),
          challengeResponse.getRealm())) {
        a1 =
            DigestUtils.toHttpDigest(
                challengeResponse.getIdentifier(),
                challengeResponse.getSecret(),
                challengeResponse.getRealm());
      }
    } else {
      a1 = new String(challengeResponse.getSecret());
    }

    if (a1 != null
        && !AuthenticatorUtils.anyNull(request.getMethod(), challengeResponse.getDigestRef())) {
      String a2 =
          DigestUtils.toMd5(
              request.getMethod().toString() + ":" + challengeResponse.getDigestRef().toString());
      StringBuilder sb =
          new StringBuilder().append(a1).append(':').append(challengeResponse.getServerNonce());

      if (!AuthenticatorUtils.anyNull(
          challengeResponse.getQuality(),
          challengeResponse.getClientNonce(),
          challengeResponse.getServerNounceCount())) {
        sb.append(':')
            .append(AuthenticatorUtils.formatNonceCount(challengeResponse.getServerNounceCount()))
            .append(':')
            .append(challengeResponse.getClientNonce())
            .append(':')
            .append(challengeResponse.getQuality());
      }

      sb.append(':').append(a2);

      return DigestUtils.toMd5(sb.toString()).toCharArray();
    }

    return null;
  }
  @Override
  public void handle(Request request, Response response) {
    super.handle(request, response);

    if (Method.GET.equals(request.getMethod())) {
      response.setEntity(getSwagger());
    } else {
      response.setStatus(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED);
    }
  }
 @Override
 protected void writeStartLine() throws IOException {
   Request request = getMessage().getRequest();
   getLineBuilder().append(request.getMethod().getName());
   getLineBuilder().append(' ');
   getLineBuilder()
       .append(ReferenceUtils.format(request.getResourceRef(), getHelper().isProxying(), request));
   getLineBuilder().append(' ');
   getLineBuilder().append(getVersion(request));
   getLineBuilder().append("\r\n");
 }
 @Override
 public void init(Context context, Request request, Response response) {
   // System.out.println("init" + request + " " + response);
   // System.out.println("Content-Type: " +
   // request.getEntity().getMediaType());
   if (request.getMethod().compareTo(Method.GET) == 0) {
     Representation entity = request.getEntity();
     System.out.println(
         "Entity " + entity + " Content-Type: " + request.getEntity().getMediaType());
     request.setEntity(new StringRepresentation(""));
   }
   super.init(context, request, response);
 }
Beispiel #13
0
          @Override
          public void handle(Request request, Response response) {
            if (request.getMethod() == Method.GET) {
              String dbName = (String) request.getAttributes().get("dbname");
              try {
                storageInstance.dropDB(dbName); //
                Logger.stderr(dbName + " db dropped.");
              } catch (StorageException e) {
                e.printStackTrace();
              }

              String r = "{\"dropped dbName\" : \"" + dbName + "\"}";

              response.setEntity(r, MediaType.APPLICATION_JSON);
            }
          }
  @Override
  public void handle(Request request, Response response) {
    super.handle(request, response);

    try {
      if (request.getMethod().equals(Method.GET)) {

        try {
          if ("users".equalsIgnoreCase(request.getResourceRef().getLastSegment())) {
            UserListValue users = importer.users();
            StringRepresentation result =
                new StringRepresentation(
                    users.toJSON(),
                    MediaType.APPLICATION_JSON,
                    Language.DEFAULT,
                    CharacterSet.UTF_8);
            response.setStatus(Status.SUCCESS_OK);
            response.setEntity(result);
          } else if ("groups".equalsIgnoreCase(request.getResourceRef().getLastSegment())) {
            GroupListValue groups = importer.groups();
            StringRepresentation result =
                new StringRepresentation(
                    groups.toJSON(),
                    MediaType.APPLICATION_JSON,
                    Language.DEFAULT,
                    CharacterSet.UTF_8);
            response.setStatus(Status.SUCCESS_OK);
            response.setEntity(result);
          }
        } catch (ResourceException e) {
          response.setStatus(Status.CLIENT_ERROR_UNAUTHORIZED);
          response.setEntity(e.getStatus().getDescription(), MediaType.TEXT_PLAIN);
        }

      } else {
        response.setStatus(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED);
      }
    } finally {
      request.release();
    }
  }
Beispiel #15
0
          @Override
          public void handle(Request request, Response response) {

            String dbName = (String) request.getAttributes().get("dbname");
            String collection = (String) request.getAttributes().get("collection");

            if (request.getMethod() == Method.GET) {
              try {
                List<Map<String, Object>> list = storageInstance.getIndex(dbName, collection);
                ObjectMapper om = new ObjectMapper();
                String r = null;
                try {
                  r = om.writeValueAsString(list);
                } catch (IOException e) {
                  e.printStackTrace();
                }
                response.setEntity(r, MediaType.APPLICATION_JSON);
              } catch (StorageException e) {
                Logger.stderr(GET_INDEX_ERROR_MESSAGE + e);
              }
            }
          }
Beispiel #16
0
          @Override
          public void handle(Request request, Response response) {

            String dbName = (String) request.getAttributes().get("dbname");
            String collection = (String) request.getAttributes().get("collection");

            if (request.getMethod() == Method.POST) {
              try {
                String text = request.getEntityAsText();
                System.out.println(text);
                TypeReference<List<Map<String, Object>>> typeRef =
                    new TypeReference<List<Map<String, Object>>>() {};
                List<Map<String, Object>> list = null;
                Map<String, Object> key = null;
                Map<String, Object> query = null;

                try {
                  list = om.readValue(text, typeRef);
                  if (list.size() != 2) {
                    Logger.stderr(TYPE_ERROR_MESSAGE);
                    return;
                  }
                  key = list.get(0);
                  query = list.get(1);
                } catch (Exception e) {
                  Logger.stderr(OBJECT_MAPPING_ERROR_MESSAGE + e);
                  return;
                }

                storageInstance.update(dbName, collection, key, query);
                response.setEntity(text, MediaType.APPLICATION_JSON);
              } catch (StorageException e) {
                e.printStackTrace();
              }
            }
          }
Beispiel #17
0
  /**
   * Handle the call and follow redirection for safe methods.
   *
   * @param request The request to send.
   * @param response The response to update.
   * @param references The references that caused a redirection to prevent infinite loops.
   * @param retryAttempt The number of remaining attempts.
   * @param next The next handler handling the call.
   */
  private void handle(
      Request request,
      Response response,
      List<Reference> references,
      int retryAttempt,
      Uniform next) {
    if (next != null) {
      // Actually handle the call
      next.handle(request, response);

      // Check for redirections
      if (isFollowingRedirects()
          && response.getStatus().isRedirection()
          && (response.getLocationRef() != null)) {
        boolean doRedirection = false;

        if (request.getMethod().isSafe()) {
          doRedirection = true;
        } else {
          if (Status.REDIRECTION_SEE_OTHER.equals(response.getStatus())) {
            // The user agent is redirected using the GET method
            request.setMethod(Method.GET);
            request.setEntity(null);
            doRedirection = true;
          } else if (Status.REDIRECTION_USE_PROXY.equals(response.getStatus())) {
            doRedirection = true;
          }
        }

        if (doRedirection) {
          Reference newTargetRef = response.getLocationRef();

          if ((references != null) && references.contains(newTargetRef)) {
            getLogger().warning("Infinite redirection loop detected with URI: " + newTargetRef);
          } else if (request.getEntity() != null && !request.isEntityAvailable()) {
            getLogger()
                .warning(
                    "Unable to follow the redirection because the request entity isn't available anymore.");
          } else {
            if (references == null) {
              references = new ArrayList<Reference>();
            }

            // Add to the list of redirection reference
            // to prevent infinite loops
            references.add(request.getResourceRef());
            request.setResourceRef(newTargetRef);
            handle(request, response, references, 0, next);
          }
        }
      } else if (isRetryOnError()
          && response.getStatus().isRecoverableError()
          && request.getMethod().isIdempotent()
          && (retryAttempt < getRetryAttempts())
          && ((request.getEntity() == null) || request.getEntity().isAvailable())) {
        getLogger()
            .log(
                Level.INFO,
                "A recoverable error was detected ("
                    + response.getStatus().getCode()
                    + "), attempting again in "
                    + getRetryDelay()
                    + " ms.");

        // Wait before attempting again
        if (getRetryDelay() > 0) {
          try {
            Thread.sleep(getRetryDelay());
          } catch (InterruptedException e) {
            getLogger().log(Level.FINE, "Retry delay sleep was interrupted", e);
          }
        }

        // Retry the call
        handle(request, response, references, ++retryAttempt, next);
      }
    }
  }
  /**
   * Handles a call.
   *
   * @param request The request to handle.
   * @param response The response to update.
   */
  @Override
  public void handle(Request request, Response response) {
    Connection connection = null;

    if (request.getMethod().equals(Method.POST)) {
      try {
        // Parse the JDBC URI
        String connectionURI = request.getResourceRef().toString();

        // Parse the request to extract necessary info
        DocumentBuilder docBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
        Document requestDoc = docBuilder.parse(new InputSource(request.getEntity().getReader()));

        Element rootElt = (Element) requestDoc.getElementsByTagName("request").item(0);
        Element headerElt = (Element) rootElt.getElementsByTagName("header").item(0);
        Element connectionElt = (Element) headerElt.getElementsByTagName("connection").item(0);

        // Read the connection pooling setting
        Node usePoolingNode = connectionElt.getElementsByTagName("usePooling").item(0);
        boolean usePooling = usePoolingNode.getTextContent().equals("true") ? true : false;

        // Read the paging setting
        Node startNode = headerElt.getElementsByTagName("start").item(0);
        int start =
            startNode != null && startNode.getTextContent().trim().length() > 0
                ? Integer.parseInt(startNode.getTextContent())
                : 0;

        Node limitNode = headerElt.getElementsByTagName("limit").item(0);
        int limit =
            limitNode != null && limitNode.getTextContent().trim().length() > 0
                ? Integer.parseInt(limitNode.getTextContent())
                : -1;

        // Read the connection properties
        NodeList propertyNodes = connectionElt.getElementsByTagName("property");
        Node propertyNode = null;
        Properties properties = null;
        String name = null;
        String value = null;
        for (int i = 0; i < propertyNodes.getLength(); i++) {
          propertyNode = propertyNodes.item(i);

          if (properties == null) {
            properties = new Properties();
          }
          name = propertyNode.getAttributes().getNamedItem("name").getTextContent();
          value = propertyNode.getTextContent();
          properties.setProperty(name, value);
        }

        Node returnGeneratedKeysNode =
            headerElt.getElementsByTagName("returnGeneratedKeys").item(0);
        boolean returnGeneratedKeys =
            returnGeneratedKeysNode.getTextContent().equals("true") ? true : false;

        // Read the SQL body and get the list of sql statements
        Element bodyElt = (Element) rootElt.getElementsByTagName("body").item(0);
        NodeList statementNodes = bodyElt.getElementsByTagName("statement");
        List<String> sqlRequests = new ArrayList<String>();
        for (int i = 0; i < statementNodes.getLength(); i++) {
          String sqlRequest = statementNodes.item(i).getTextContent();
          sqlRequests.add(sqlRequest);
        }

        // Execute the List of SQL requests
        connection = getConnection(connectionURI, properties, usePooling);
        JdbcResult result = handleSqlRequests(connection, returnGeneratedKeys, sqlRequests);
        response.setEntity(new RowSetRepresentation(result, start, limit));
      } catch (SQLException se) {
        getLogger().log(Level.WARNING, "Error while processing the SQL request", se);
        response.setStatus(Status.SERVER_ERROR_INTERNAL, se);
      } catch (ParserConfigurationException pce) {
        getLogger().log(Level.WARNING, "Error with XML parser configuration", pce);
        response.setStatus(Status.CLIENT_ERROR_BAD_REQUEST, pce);
      } catch (SAXException se) {
        getLogger().log(Level.WARNING, "Error while parsing the XML document", se);
        response.setStatus(Status.CLIENT_ERROR_BAD_REQUEST, se);
      } catch (IOException ioe) {
        getLogger().log(Level.WARNING, "Input/Output exception", ioe);
        response.setStatus(Status.SERVER_ERROR_INTERNAL, ioe);
      }
    } else {
      throw new IllegalArgumentException("Only the POST method is supported");
    }
  }
Beispiel #19
0
  /**
   * ShareResource
   *
   * @param context
   * @param request
   * @param response
   * @throws UnsupportedEncodingException
   */
  @Override
  public void doInit() {
    Request request = this.getRequest();

    Map<String, Object> attributes = request.getAttributes();
    urlStr = request.getResourceRef().toString();

    // Every user must pass in their cookies
    cookie = request.getCookies().getFirstValue("infinitecookie", true);

    // Method.POST
    if (request.getMethod() == Method.POST) {
      if (RESTTools.decodeRESTParam("id", attributes) != null)
        id = RESTTools.decodeRESTParam("id", attributes);
      if (RESTTools.decodeRESTParam("type", attributes) != null)
        type = RESTTools.decodeRESTParam("type", attributes);
      if (RESTTools.decodeRESTParam("title", attributes) != null)
        title = RESTTools.decodeRESTParam("title", attributes);
      if (RESTTools.decodeRESTParam("description", attributes) != null)
        description = RESTTools.decodeRESTParam("description", attributes);
    }

    // Method.GET
    if (request.getMethod() == Method.GET) {
      // Method.GET
      Map<String, String> queryOptions = this.getQuery().getValuesMap();

      // Query String Values
      if (queryOptions.get("id") != null) id = queryOptions.get("id");
      if (queryOptions.get("skip") != null) skip = queryOptions.get("skip");
      if (queryOptions.get("limit") != null) limit = queryOptions.get("limit");
      if (queryOptions.get("searchby") != null) searchby = queryOptions.get("searchby");
      if (queryOptions.get("json") != null) json = queryOptions.get("json");
      if (queryOptions.get("type") != null) type = queryOptions.get("type");
      if ((queryOptions.get("ignoreAdmin") != null)
          && (queryOptions.get("ignoreAdmin").equalsIgnoreCase("true"))) {
        ignoreAdmin = true;
      }
      if ((queryOptions.get("nocontent") != null)
          && (queryOptions.get("nocontent").equalsIgnoreCase("true"))) {
        returnContent = false;
      }
      if ((queryOptions.get("nometa") != null)
          && (queryOptions.get("nometa").equalsIgnoreCase("true"))) {
        jsonOnly = true;
      }

      // Get Share by ID
      if (urlStr.contains("/share/get/")) {
        shareId = RESTTools.decodeRESTParam("id", attributes);
        action = "getShare";
      }

      // Search Shares by Owner, Community, Type
      else if (urlStr.contains("/share/search")) {
        action = "searchShares";
      }

      // Save a JSON share object to the DB
      // /social/share/save/json/{id}/{type}/{title}/{description}/?json={...}
      else if (urlStr.contains("/share/save/json/")
          || urlStr.contains("/share/add/json/")
          || urlStr.contains("/share/update/json/")) {
        if (RESTTools.decodeRESTParam("id", attributes) != null)
          id = RESTTools.decodeRESTParam("id", attributes);
        type = RESTTools.decodeRESTParam("type", attributes);
        title = RESTTools.decodeRESTParam("title", attributes);
        description = RESTTools.decodeRESTParam("description", attributes);
        // Use URLDecoder on the json string
        try {
          json = URLDecoder.decode(json, "UTF-8");
          action = "saveJson";
        } catch (UnsupportedEncodingException e) {
          // TODO can't throw exceptions
          // set to failed so it doesn't run
          // throw e;
          action = "failed";
        }

      } else if (urlStr.contains("/share/add/binary/")) {
        action = "addBinaryGET";
      } else if (urlStr.contains("/share/update/binary/")) {
        action = "updateBinaryGET";
      }

      // Add a Ref (Pointer to a record within a collection)
      else if (urlStr.contains("/share/add/ref/")) {
        type = RESTTools.decodeRESTParam("type", attributes);
        documentId = RESTTools.decodeRESTParam("documentid", attributes);
        title = RESTTools.decodeRESTParam("title", attributes);
        description = RESTTools.decodeRESTParam("description", attributes);
        action = "addRef";
      }

      // Add a Ref (Pointer to a record within a collection)
      else if (urlStr.contains("/share/update/ref/")) {
        id = RESTTools.decodeRESTParam("id", attributes);
        type = RESTTools.decodeRESTParam("type", attributes);
        documentId = RESTTools.decodeRESTParam("documentid", attributes);
        title = RESTTools.decodeRESTParam("title", attributes);
        description = RESTTools.decodeRESTParam("description", attributes);
        action = "updateRef";
      }

      // Share - Remove a community from a share
      else if (urlStr.contains("/share/remove/community/")) {
        shareId = RESTTools.decodeRESTParam("shareid", attributes);
        communityId = RESTTools.decodeRESTParam("communityid", attributes);
        action = "removeCommunity";
      }

      // Remove share
      else if (urlStr.contains("/share/remove/")) {
        shareId = RESTTools.decodeRESTParam("shareid", attributes);
        action = "removeShare";
      }

      // Endorse share
      else if (urlStr.contains("/share/endorse/")) {
        shareId = RESTTools.decodeRESTParam("shareid", attributes);
        communityId = RESTTools.decodeRESTParam("communityid", attributes);
        isEndorsed = Boolean.parseBoolean(RESTTools.decodeRESTParam("isendorsed", attributes));
        action = "endorseShare";
      }

      // Share - Add a community so that members can view the share
      else if (urlStr.contains("/share/add/community/")) {
        shareId = RESTTools.decodeRESTParam("shareid", attributes);
        communityId = RESTTools.decodeRESTParam("communityid", attributes);
        comment = RESTTools.decodeRESTParam("comment", attributes);
        action = "addCommunity";
      }
    }
  }