/**
   * Handles a GET call.
   *
   * @param request The request to answer.
   * @param response The response to update.
   * @param file The Zip archive file.
   * @param entryName The Zip archive entry name.
   * @param metadataService The metadata service.
   */
  protected void handleGet(
      Request request,
      Response response,
      File file,
      String entryName,
      final MetadataService metadataService) {

    if (!file.exists()) {
      response.setStatus(Status.CLIENT_ERROR_NOT_FOUND);
    } else {
      ZipFile zipFile;

      try {
        zipFile = new ZipFile(file);
      } catch (Exception e) {
        response.setStatus(Status.SERVER_ERROR_INTERNAL, e);
        return;
      }

      Entity entity = new ZipEntryEntity(zipFile, entryName, metadataService);
      if (!entity.exists()) {
        response.setStatus(Status.CLIENT_ERROR_NOT_FOUND);
      } else {
        final Representation output;

        if (entity.isDirectory()) {
          // Return the directory listing
          final Collection<Entity> children = entity.getChildren();
          final ReferenceList rl = new ReferenceList(children.size());
          String fileUri = LocalReference.createFileReference(file).toString();
          String scheme = request.getResourceRef().getScheme();
          String baseUri = scheme + ":" + fileUri + "!/";

          for (final Entity entry : children) {
            rl.add(baseUri + entry.getName());
          }

          output = rl.getTextRepresentation();

          try {
            zipFile.close();
          } catch (IOException e) {
            // Do something ???
          }
        } else {
          // Return the file content
          output = entity.getRepresentation(metadataService.getDefaultMediaType(), getTimeToLive());
          output.setLocationRef(request.getResourceRef());
          Entity.updateMetadata(entity.getName(), output, true, getMetadataService());
        }

        response.setStatus(Status.SUCCESS_OK);
        response.setEntity(output);
      }
    }
  }
 /** Tests resource reference getting/setting. */
 public void testResourceRef() throws Exception {
   final Request request = getRequest();
   String uri = "http://www.restlet.org/";
   Reference reference = getReference(uri);
   request.setResourceRef(uri);
   assertEquals(reference, request.getResourceRef());
   uri = "http://www.restlet.org/something";
   reference = getReference(uri);
   request.setResourceRef(reference);
   assertEquals(reference, request.getResourceRef());
 }
  @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);
  }
  @Before
  public void setUp() throws Exception {
    contactsRepository = ContactsRepository.getInstance();
    contactsRepository.setDbService(dbService);
    attributes = new ConcurrentHashMap<String, Object>();
    Subject subjectUnderTest = Mockito.mock(Subject.class);
    setSubject(subjectUnderTest);
    request = Mockito.mock(Request.class);
    Mockito.when(request.getClientInfo()).thenReturn(new ClientInfo());
    Mockito.when(request.getAttributes()).thenReturn(attributes);
    Reference targetRef = Mockito.mock(Reference.class);
    Reference resourceRef = Mockito.mock(Reference.class);
    Mockito.when(request.getResourceRef()).thenReturn(resourceRef);
    Mockito.when(resourceRef.getTargetRef()).thenReturn(targetRef);
    response = new Response(request);

    ValidatorService validatorService = Mockito.mock(ValidatorService.class);
    Validator validator = Mockito.mock(Validator.class);
    Mockito.when(validatorService.getValidator()).thenReturn(validator);
    Mockito.when(clipboardApplication.getValidatorService()).thenReturn(validatorService);

    RouteBuilder routeBuilder = Mockito.mock(RouteBuilder.class);
    Mockito.when(clipboardApplication.getRouteBuilders(Mockito.any()))
        .thenReturn(Arrays.asList(routeBuilder));
  }
  @Override
  public void formatResponse(
      ChallengeWriter cw,
      ChallengeResponse challenge,
      Request request,
      Series<Header> httpHeaders) {

    if (challenge.getIdentifier() != null) {
      cw.appendQuotedChallengeParameter("username", challenge.getIdentifier());
    }

    if (challenge.getRealm() != null) {
      cw.appendQuotedChallengeParameter("realm", challenge.getRealm());
    }

    if (challenge.getServerNonce() != null) {
      cw.appendQuotedChallengeParameter("nonce", challenge.getServerNonce());
    }

    if (challenge.getDigestRef() != null) {
      challenge.setDigestRef(new Reference(request.getResourceRef().getPath()));
      cw.appendQuotedChallengeParameter("uri", challenge.getDigestRef().toString());
    }

    char[] responseDigest = formatResponseDigest(challenge, request);

    if (responseDigest != null) {
      cw.appendQuotedChallengeParameter("response", new String(responseDigest));
    }

    if ((challenge.getDigestAlgorithm() != null)
        && !Digest.ALGORITHM_MD5.equals(challenge.getDigestAlgorithm())) {
      cw.appendChallengeParameter("algorithm", challenge.getDigestAlgorithm());
    }

    if (challenge.getClientNonce() != null) {
      cw.appendQuotedChallengeParameter("cnonce", challenge.getClientNonce());
    }

    if (challenge.getOpaque() != null) {
      cw.appendQuotedChallengeParameter("opaque", challenge.getOpaque());
    }

    if (challenge.getQuality() != null) {
      cw.appendChallengeParameter("qop", challenge.getQuality());
    }

    if ((challenge.getQuality() != null) && (challenge.getServerNounceCount() > 0)) {
      cw.appendChallengeParameter("nc", challenge.getServerNounceCountAsHex());
    }

    for (Parameter param : challenge.getParameters()) {
      if (HeaderUtils.isToken(param.getValue())) {
        cw.appendChallengeParameter(param);
      } else {
        cw.appendQuotedChallengeParameter(param);
      }
    }
  }
 @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 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();
    }
  }
 private String extractTokenFromRequest(Request request) {
   String token = null;
   if (request != null) {
     log.debug(request);
     if (request.getResourceRef() != null && request.getResourceRef().getQueryAsForm() != null) {
       token = request.getResourceRef().getQueryAsForm().getFirstValue("token");
       log.trace("Found token from query string: " + token);
     } else {
       log.info("ResourceRef is null");
     }
     for (Cookie cookie : request.getCookies()) {
       log.trace(cookie.getName() + " - " + cookie.getValue());
       if (RestAuthenticationService.ES_DMS_TICKET.equals(cookie.getName())) {
         token = cookie.getValue();
         log.trace("Found token from cookie: " + token);
         break;
       }
     }
   }
   return token;
 }
  /**
   * Returns the target reference to redirect to by automatically resolving URI template variables
   * found using the {@link Template} class using the request and response as data models.
   *
   * @param request The request to handle.
   * @param response The response to update.
   * @return The target reference to redirect to.
   */
  protected Reference getTargetRef(Request request, Response response) {
    // Create the template
    Template rt = new Template(this.targetTemplate);
    rt.setLogger(getLogger());

    // Return the formatted target URI
    if (new Reference(this.targetTemplate).isRelative()) {
      // Be sure to keep the resource's base reference.
      return new Reference(request.getResourceRef(), rt.format(request, response));
    }

    return new Reference(rt.format(request, response));
  }
  @Post("application/x-www-form-urlencoded|multipart/form-data")
  public Representation postWebFormMedia(Representation entity) {
    setServerHeader();

    Request request = getRequest();
    //		The HTTP API sets the headers
    //		addCORSHeaders(request);

    String auth = getQueryValue(Constants.AUTH_QUERY);

    String userId = null;
    String token = null;

    try {
      userId = getUserId(request, auth);
      token = getTransactionId(request, auth);
    } catch (Throwable t) {
      setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
      return new StringRepresentation(t.getLocalizedMessage(), MediaType.APPLICATION_JSON);
    }

    Representation checkRequest =
        checkRequest(userId, token, request.getResourceRef().getIdentifier());
    if (checkRequest != null) {
      return checkRequest;
    }

    MediaDAO mediaDAO = DAOFactory.getInstance().getDAO();

    String entityId = (String) request.getAttributes().get(Constants.ENTITY_ARG);

    String result = "";
    try {
      if (MediaType.MULTIPART_FORM_DATA.equals(entity.getMediaType(), true)) {
        result = mediaDAO.insertFormDataMedia(userId, entityId, getRequest(), false);
      } else {
        result = mediaDAO.insertWebFormMedia(userId, entityId, new Form(entity), false);
      }

      setStatus(Status.SUCCESS_CREATED);
    } catch (FileUploadException e) {
      setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
    } catch (UserNotAllowedException e) {
      setStatus(Status.CLIENT_ERROR_FORBIDDEN);
    } catch (Throwable t) {
      return unexpectedError(t);
    }

    return new StringRepresentation(result, MediaType.APPLICATION_JSON);
  }
  /**
   * Redirects a given call to a target reference. In the default implementation, the request HTTP
   * headers, stored in the request's attributes, are removed before dispatching. After dispatching,
   * the response HTTP headers are also removed to prevent conflicts with the main call.
   *
   * @param targetRef The target reference with URI variables resolved.
   * @param request The request to handle.
   * @param response The response to update.
   */
  protected void outboundServerRedirect(Reference targetRef, Request request, Response response) {
    Restlet next = (getApplication() == null) ? null : getApplication().getOutboundRoot();

    if (next == null) {
      next = getContext().getClientDispatcher();
    }

    serverRedirect(next, targetRef, request, response);
    if (response.getEntity() != null
        && !request.getResourceRef().getScheme().equalsIgnoreCase(targetRef.getScheme())) {
      // Distinct protocol, this data cannot be exposed.
      response.getEntity().setLocationRef((Reference) null);
    }
  }
  @Override
  public FilterResult doHandle(R resource, Request request, ResponseWrapper<T> response) {
    logger.debug("entering {}#doHandle", this.getClass().getSimpleName());
    if (request == null || request.getResourceRef() == null) {
      response.setSkysailResponse(new FailureResponse<T>("request or resource reference was null"));
      return FilterResult.STOP;
    }
    Form form =
        (Form) request.getAttributes().get(EntityServerResource.SKYSAIL_SERVER_RESTLET_FORM);
    T data = (T) resource.getData(form);
    response.getSkysailResponse().setMessage(resource.getMessage("tobedone"));
    response.getSkysailResponse().setData(data);

    super.doHandle(resource, request, response);

    return FilterResult.CONTINUE;
  }
 /** Tests context's base reference getting/setting. */
 public void testBaseRef() throws Exception {
   final Request request = getRequest();
   final String resourceRefURI = "http://www.restlet.org/path/to/resource";
   final Reference resourceRef = getReference(resourceRefURI);
   request.setResourceRef(resourceRefURI);
   assertEquals(resourceRef, request.getResourceRef());
   String uri = "http://www.restlet.org/path";
   Reference reference = getReference(uri);
   request.getResourceRef().setBaseRef(uri);
   assertEquals(uri, request.getResourceRef().getBaseRef().toString());
   assertEquals(reference, request.getResourceRef().getBaseRef());
   uri = "http://www.restlet.org/path/to";
   reference = getReference(uri);
   request.getResourceRef().setBaseRef(uri);
   assertEquals(uri, request.getResourceRef().getBaseRef().toString());
   assertEquals(reference, request.getResourceRef().getBaseRef());
 }
    @Override
    public void handle(Request request, Response response) {
      Form form = request.getResourceRef().getQueryAsForm();
      List<Range> ranges = request.getRanges();
      boolean match = false;

      for (Parameter parameter : form) {
        long index = 0;
        long length = 0;
        String value = parameter.getValue();
        if (value.startsWith("-")) {
          index = Range.INDEX_LAST;
          length = Long.parseLong(value.substring(1));
        } else if (value.endsWith("-")) {
          index = Long.parseLong(value.substring(0, value.length() - 1));
          length = Range.SIZE_MAX;
        } else {
          String[] tab = value.split("-");
          if (tab.length == 2) {
            index = Long.parseLong(tab[0]);
            length = Long.parseLong(tab[1]) - index;
          }
        }

        boolean found = false;
        for (Range range : ranges) {
          found = (index == range.getIndex()) && (length == range.getSize());
          if (found) {
            break;
          }
        }
        if (!found) {
          break;
        }
        match = true;
      }
      if (match) {
        response.setStatus(Status.SUCCESS_OK);
        response.setEntity(str1000, MediaType.TEXT_PLAIN);
      } else {
        response.setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
      }
    }
  @Override
  public void formatResponse(
      ChallengeWriter cw,
      ChallengeResponse challenge,
      Request request,
      Series<Header> httpHeaders) {

    // Setup the Date header
    String date = "";

    if (httpHeaders.getFirstValue("x-ms-date", true) == null) {
      // X-ms-Date header didn't override the standard Date header
      date = httpHeaders.getFirstValue(HeaderConstants.HEADER_DATE, true);

      if (date == null) {
        // Add a fresh Date header
        date = DateUtils.format(new Date(), DateUtils.FORMAT_RFC_1123.get(0));
        httpHeaders.add(HeaderConstants.HEADER_DATE, date);
      }
    } else {
      date = httpHeaders.getFirstValue("x-ms-date", true);
    }

    // Setup the canonicalized path
    String canonicalizedResource = getCanonicalizedResourceName(request.getResourceRef());

    // Setup the message part
    StringBuilder rest = new StringBuilder();
    rest.append(date)
        .append('\n')
        .append('/')
        .append(challenge.getIdentifier())
        .append(canonicalizedResource);

    // Append the SharedKey credentials
    cw.append(challenge.getIdentifier())
        .append(':')
        .append(
            Base64.encode(
                DigestUtils.toHMacSha256(rest.toString(), Base64.decode(challenge.getSecret())),
                true));
  }
  /**
   * Redirects a given call on the server-side to a next Restlet with a given target reference. In
   * the default implementation, the request HTTP headers, stored in the request's attributes, are
   * removed before dispatching. After dispatching, the response HTTP headers are also removed to
   * prevent conflicts with the main call.
   *
   * @param next The next Restlet to forward the call to.
   * @param targetRef The target reference with URI variables resolved.
   * @param request The request to handle.
   * @param response The response to update.
   */
  protected void serverRedirect(
      Restlet next, Reference targetRef, Request request, Response response) {
    if (next == null) {
      getLogger().warning("No next Restlet provided for server redirection to " + targetRef);
    } else {
      // Save the base URI if it exists as we might need it for
      // redirections
      Reference resourceRef = request.getResourceRef();
      Reference baseRef = resourceRef.getBaseRef();

      // Reset the protocol and let the dispatcher handle the protocol
      request.setProtocol(null);

      // Update the request to cleanly go to the target URI
      request.setResourceRef(targetRef);
      request.getAttributes().remove(HeaderConstants.ATTRIBUTE_HEADERS);
      next.handle(request, response);

      // Allow for response rewriting and clean the headers
      response.setEntity(rewrite(response.getEntity()));
      response.getAttributes().remove(HeaderConstants.ATTRIBUTE_HEADERS);
      request.setResourceRef(resourceRef);

      // In case of redirection, we may have to rewrite the redirect URI
      if (response.getLocationRef() != null) {
        Template rt = new Template(this.targetTemplate);
        rt.setLogger(getLogger());
        int matched = rt.parse(response.getLocationRef().toString(), request);

        if (matched > 0) {
          String remainingPart = (String) request.getAttributes().get("rr");

          if (remainingPart != null) {
            response.setLocationRef(baseRef.toString() + remainingPart);
          }
        }
      }
    }
  }
 /**
  * Decodes form parameters that are sent double encoded by performing one decode step on their
  * values, if their restlet framework decoded value starts with an "%".
  *
  * @param request a restlet request
  * @throws IOException did not occur during tests but may.
  * @throws IllegalArgumentException if an Encode representation is received.
  */
 void decodeFormParamsIfDoubleEncoded(Request request) throws IOException {
   Representation r = request.getEntity();
   if (r instanceof EncodeRepresentation)
     throw new IllegalArgumentException(
         "Received an Encode representation."
             + " This filter must be after the Encoder filter. please check your filter chain order.");
   if (!(r instanceof EmptyRepresentation)) {
     ContentType c = new ContentType(r);
     if (MediaType.APPLICATION_WWW_FORM.equals(c.getMediaType(), true)) {
       Form form = new Form(r);
       Form newform = new Form(r);
       Map<String, String> valuesMap = form.getValuesMap();
       for (Map.Entry<String, String> e : valuesMap.entrySet()) {
         if (DBG) ThreadLocalStopwatch.now("" + e.getKey() + " - " + e.getValue());
         String shouldBeDecodedValue = e.getValue();
         if (shouldBeDecodedValue.startsWith("%")) {
           shouldBeDecodedValue = URLDecoder.decode(e.getValue(), DECODER_CHAR_SET);
           totalDecodings.incrementAndGet();
           if (DBG) {
             ThreadLocalStopwatch.now("DECODED " + request.getResourceRef());
             ThreadLocalStopwatch.now(
                 "DECODED "
                     + totalDecodings.get()
                     + " : "
                     + e.getKey()
                     + " - "
                     + shouldBeDecodedValue);
           }
         }
         newform.add(e.getKey(), shouldBeDecodedValue);
       }
       // we must always set the entity, because above getEntitiy call causes
       // NPEs later if repeated by the framework.
       request.setEntity(newform.encode(), c.getMediaType());
     }
   }
 }
  /**
   * 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");
    }
  }
  @Override
  public List<Predicat> createPredicats(Request request, List<Predicat> predicats)
      throws Exception {
    // Get the dataset
    DataSetApplication dsApplication = null;
    DataSet ds = null;
    boolean isConcept = true;
    Form params = request.getResourceRef().getQueryAsForm();
    boolean filterExists = true;
    int i = 0;
    // Build predicat for filters param
    while (filterExists) {
      // first check if the filter is applied on a Concept or not
      String index = TEMPLATE_PARAM_CONCEPT.replace("#", Integer.toString(i));
      String formParam = params.getFirstValue(index);
      if (formParam == null) {
        isConcept = false;
        index = TEMPLATE_PARAM.replace("#", Integer.toString(i));
        formParam = params.getFirstValue(index);
      }
      i++;
      if (formParam != null) {
        String[] parameters = formParam.split("\\|");
        TYPE_COMPONENT[] types = TYPE_COMPONENT.values();
        Boolean trouve = false;
        for (TYPE_COMPONENT typeCmp : types) {
          if (typeCmp.name().equals(parameters[TYPE])) {
            trouve = true;
          }
        }
        if (trouve) {
          if (dsApplication == null) {
            dsApplication =
                (DataSetApplication) getContext().getAttributes().get("DataSetApplication");
            ds = dsApplication.getDataSet();
          }
          String columnAlias = null;
          if (parameters.length >= VALUES) {

            /*
             * columnsAlias = parameters[COLUMN].split(","); ArrayList<Column> columns = new ArrayList<Column>(); for
             * (String columnAlias : columnsAlias) { Column col = ds.findByColumnAlias(columnAlias); if (col != null) {
             * columns.add(col); }
             *
             * }
             */
            columnAlias = getColumnAlias(isConcept, parameters, dsApplication);
            if (columnAlias != null) {
              Column col = ds.findByColumnAlias(columnAlias);
              if (col != null
                  && col.getFilter() != null
                  && col.getFilter()
                  && checkValues(parameters, col)) {
                Predicat predicat = new Predicat();
                predicat.setLeftAttribute(col);
                predicat.setNbOpenedParanthesis(1);
                predicat.setNbClosedParanthesis(0);
                predicat.setCompareOperator(Operator.GTE);
                predicat.setRightValue(numericBetween.getFrom());
                predicats.add(predicat);
                predicat = new Predicat();
                predicat.setLeftAttribute(col);
                predicat.setNbOpenedParanthesis(0);
                predicat.setNbClosedParanthesis(1);
                predicat.setCompareOperator(Operator.LTE);
                predicat.setRightValue(numericBetween.getTo());
                predicats.add(predicat);
              }
            }
          }
        }
      } else {
        filterExists = false;
      }
    }

    return predicats;
  }
Exemple #21
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";
      }
    }
  }
  /**
   * Tests partial Put requests.
   *
   * @throws Exception
   */
  public void testPut() throws Exception {
    if (!SystemUtils.isWindows()) {
      Request request;
      Response response;

      BioUtils.delete(testDir, true);
      Client client = new Client(new Context(), Protocol.HTTP);
      client.getContext().getParameters().add("tracing", "true");

      // PUT on a file that does not exist
      request = new Request(Method.PUT, "http://localhost:" + TEST_PORT + "/testPut/essai.txt");
      request.setEntity(new StringRepresentation("1234567890"));
      request.setRanges(Arrays.asList(new Range(0, 10)));
      response = client.handle(request);
      assertEquals(Status.SUCCESS_OK, response.getStatus());
      response = client.handle(new Request(Method.GET, request.getResourceRef()));
      assertEquals(Status.SUCCESS_OK, response.getStatus());
      assertEquals("1234567890", response.getEntity().getText());

      // Partial PUT on a file, the provided representation overflowed the
      // existing file
      request = new Request(Method.PUT, "http://localhost:" + TEST_PORT + "/testPut/essai.txt");
      request.setEntity(new StringRepresentation("0000000000"));
      request.setRanges(Arrays.asList(new Range(1, 10)));
      response = client.handle(request);
      System.out.println(response.getStatus() + " / " + response.getStatus().getThrowable());
      assertEquals(Status.SUCCESS_OK, response.getStatus());
      response = client.handle(new Request(Method.GET, request.getResourceRef()));
      assertEquals(Status.SUCCESS_OK, response.getStatus());
      assertEquals("10000000000", response.getEntity().getText());

      // Partial PUT on a file that does not exists, the provided range
      // does not start at the 0 index.
      request = new Request(Method.PUT, "http://localhost:" + TEST_PORT + "/testPut/essai2.txt");
      request.setEntity(new StringRepresentation("0000000000"));
      request.setRanges(Arrays.asList(new Range(1, 10)));
      response = client.handle(request);
      assertEquals(Status.SUCCESS_OK, response.getStatus());
      request.setMethod(Method.GET);
      response = client.handle(request);
      assertEquals(Status.SUCCESS_PARTIAL_CONTENT, response.getStatus());
      assertEquals("0000000000", response.getEntity().getText());

      // Partial PUT on a file, simple range
      request = new Request(Method.PUT, "http://localhost:" + TEST_PORT + "/testPut/essai.txt");
      request.setEntity(new StringRepresentation("22"));
      request.setRanges(Arrays.asList(new Range(2, 2)));
      response = client.handle(request);
      assertEquals(Status.SUCCESS_OK, response.getStatus());
      response = client.handle(new Request(Method.GET, request.getResourceRef()));
      assertEquals(Status.SUCCESS_OK, response.getStatus());
      assertEquals("10220000000", response.getEntity().getText());

      // Partial PUT on a file, the provided representation will be padded
      // at the very end of the file.
      request = new Request(Method.PUT, "http://localhost:" + TEST_PORT + "/testPut/essai.txt");
      request.setEntity(new StringRepresentation("888"));
      request.setRanges(Arrays.asList(new Range(8, Range.SIZE_MAX)));
      response = client.handle(request);
      assertEquals(Status.SUCCESS_OK, response.getStatus());
      response = client.handle(new Request(Method.GET, request.getResourceRef()));
      assertEquals(Status.SUCCESS_OK, response.getStatus());
      assertEquals("10220000888", response.getEntity().getText());

      // Partial PUT on a file that does not exist, the range does not
      // specify the range size.
      request = new Request(Method.PUT, "http://localhost:" + TEST_PORT + "/testPut/essai3.txt");
      request.setEntity(new StringRepresentation("888"));
      request.setRanges(Arrays.asList(new Range(8, Range.SIZE_MAX)));
      response = client.handle(request);
      assertEquals(Status.SUCCESS_OK, response.getStatus());
      request.setMethod(Method.GET);
      response = client.handle(request);
      assertEquals(Status.SUCCESS_PARTIAL_CONTENT, response.getStatus());
      assertEquals("888", response.getEntity().getText());

      // Partial PUT on a file, the provided representation will be padded
      // just before the end of the file.
      request = new Request(Method.PUT, "http://localhost:" + TEST_PORT + "/testPut/essai.txt");
      request.setEntity(new StringRepresentation("99"));
      request.setRanges(Arrays.asList(new Range(8, Range.SIZE_MAX)));
      response = client.handle(request);
      assertEquals(Status.SUCCESS_OK, response.getStatus());
      response = client.handle(new Request(Method.GET, request.getResourceRef()));
      assertEquals(Status.SUCCESS_OK, response.getStatus());
      assertEquals("10220000998", response.getEntity().getText());

      request = new Request(Method.GET, "http://localhost:" + TEST_PORT + "/testPut/essai.txt");
      request.setRanges(Arrays.asList(new Range(3, Range.SIZE_MAX)));
      response = client.handle(request);
      assertEquals(Status.SUCCESS_PARTIAL_CONTENT, response.getStatus());
      assertEquals("20000998", response.getEntity().getText());

      BioUtils.delete(testDir, true);
      client.stop();
    }
  }
  /** Gets media's information list (GET /<channel>) */
  @Get
  public Representation getMediasInfo() {
    setServerHeader();
    //		The HTTP API sets the headers
    //		addCORSHeaders();

    Request request = getRequest();

    String userId = null;
    String token = null;

    String entityId = (String) request.getAttributes().get(Constants.ENTITY_ARG);

    boolean isChannelPublic = XMPPToolBox.getInstance().getPubSubClient().isChannelPublic(entityId);

    if (!isChannelPublic) {
      String auth = getQueryValue(Constants.AUTH_QUERY);

      try {
        userId = getUserId(request, auth);
        token = getTransactionId(request, auth);
      } catch (Throwable t) {
        setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
        return new StringRepresentation(
            "Error while getting auth params", MediaType.APPLICATION_JSON);
      }

      Representation verifyRequest =
          checkRequest(userId, token, request.getResourceRef().getIdentifier());
      if (verifyRequest != null) {
        return verifyRequest;
      }
    }

    Integer max = null;
    String after = null;

    try {
      String queryValue = getQueryValue(Constants.MAX_QUERY);
      if (queryValue != null) {
        max = Integer.valueOf(queryValue);
      }

      after = getQueryValue(Constants.AFTER_QUERY);
    } catch (Throwable t) {
      setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
      return new StringRepresentation("Invalid query value!", MediaType.APPLICATION_JSON);
    }

    MediaDAO mediaDAO = DAOFactory.getInstance().getDAO();

    try {
      return new StringRepresentation(
          mediaDAO.getMediasInfo(userId, entityId, max, after), MediaType.APPLICATION_JSON);
    } catch (MetadataSourceException e) {
      setStatus(Status.SERVER_ERROR_INTERNAL);
    } catch (UserNotAllowedException e) {
      setStatus(Status.CLIENT_ERROR_FORBIDDEN);
    } catch (Throwable t) {
      return unexpectedError(t);
    }

    return new EmptyRepresentation();
  }