Examples with InputRepresentation org.restlet.representation.InputRepresentation used on opensource projects

Example 11 with InputRepresentation

use of org.restlet.representation.InputRepresentation in project xwiki-platform by xwiki.

the class FormUrlEncodedPageReader method readFrom.

@Override
public Page readFrom(Class<Page> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException {
    ObjectFactory objectFactory = new ObjectFactory();
    Page page = objectFactory.createPage();
    Representation representation = new InputRepresentation(entityStream, org.restlet.data.MediaType.APPLICATION_WWW_FORM);
    Form form = new Form(representation);
    /*
         * If the form is empty then it might have happened that some filter has invalidated the entity stream. Try to
         * read data using getParameter()
         */
    if (form.getNames().isEmpty()) {
        HttpServletRequest httpServletRequest = ServletUtils.getRequest(Request.getCurrent());
        page.setTitle(httpServletRequest.getParameter(TITLE_FIELD_NAME));
        page.setParent(httpServletRequest.getParameter(PARENT_FIELD_NAME));
        page.setHidden(Boolean.valueOf(httpServletRequest.getParameter(HIDDEN_FIELD_NAME)));
        page.setContent(httpServletRequest.getParameter(CONTENT_FIELD_NAME));
    } else {
        page.setTitle(form.getFirstValue(TITLE_FIELD_NAME));
        page.setParent(form.getFirstValue(PARENT_FIELD_NAME));
        page.setHidden(Boolean.valueOf(form.getFirstValue(HIDDEN_FIELD_NAME)));
        page.setContent(form.getFirstValue(CONTENT_FIELD_NAME));
    }
    return page;
}

Example 12 with InputRepresentation

use of org.restlet.representation.InputRepresentation in project qi4j-sdk by Qi4j.

the class SPARQLResource method get.

@Override
public Representation get(final Variant variant) throws ResourceException {
    try {
        // TODO There's probably a helper somewhere that can do this more nicely
        if (getRequest().getOriginalRef().getLastSegment().equals("sparqlhtml.xsl")) {
            InputStream resourceAsStream = getClass().getResourceAsStream("sparqlhtml.xsl");
            return new InputRepresentation(resourceAsStream, MediaType.TEXT_XML);
        }
        Form form;
        if (getRequest().getMethod().equals(Method.POST)) {
            form = new Form(getRequest().getEntity());
        } else {
            form = getRequest().getResourceRef().getQueryAsForm();
        }
        final RepositoryConnection conn = repository.getConnection();
        String queryStr = form.getFirstValue("query");
        if (queryStr == null) {
            InputStream resourceAsStream = getClass().getResourceAsStream("sparqlform.html");
            return new InputRepresentation(resourceAsStream, MediaType.TEXT_HTML);
        }
        Query query = getQuery(repository, conn, queryStr);
        if (query instanceof TupleQuery) {
            TupleQuery tQuery = (TupleQuery) query;
            final TupleQueryResult queryResult = tQuery.evaluate();
            if (variant.getMediaType().equals(MediaType.TEXT_HTML)) {
                return new OutputRepresentation(MediaType.TEXT_XML) {

                    @Override
                    public void write(OutputStream outputStream) throws IOException {
                        try {
                            PrintWriter out = new PrintWriter(outputStream);
                            out.println("<?xml version='1.0' encoding='UTF-8'?>");
                            out.println("<?xml-stylesheet type=\"text/xsl\" href=\"query/sparqlhtml.xsl\"?>");
                            out.flush();
                            TupleQueryResultWriter qrWriter = new SPARQLResultsXMLWriter(new XMLWriter(outputStream) {

                                @Override
                                public void startDocument() throws IOException {
                                // Ignore
                                }
                            });
                            QueryResultUtil.report(queryResult, qrWriter);
                        } catch (Exception e) {
                            throw new IOException(e);
                        } finally {
                            try {
                                conn.close();
                            } catch (RepositoryException e) {
                            // Ignore
                            }
                        }
                    }
                };
            } else if (variant.getMediaType().equals(MediaType.APPLICATION_RDF_XML)) {
                return new OutputRepresentation(MediaType.APPLICATION_XML) {

                    @Override
                    public void write(OutputStream outputStream) throws IOException {
                        try {
                            TupleQueryResultWriter qrWriter = new SPARQLResultsXMLWriter(new XMLWriter(outputStream));
                            QueryResultUtil.report(queryResult, qrWriter);
                        } catch (Exception e) {
                            throw new IOException(e);
                        } finally {
                            try {
                                conn.close();
                            } catch (RepositoryException e) {
                            // Ignore
                            }
                        }
                    }
                };
            } else if (variant.getMediaType().equals(RestApplication.APPLICATION_SPARQL_JSON)) {
                return new OutputRepresentation(RestApplication.APPLICATION_SPARQL_JSON) {

                    @Override
                    public void write(OutputStream outputStream) throws IOException {
                        try {
                            TupleQueryResultWriter qrWriter = new SPARQLResultsJSONWriterFactory().getWriter(outputStream);
                            QueryResultUtil.report(queryResult, qrWriter);
                        } catch (Exception e) {
                            throw new IOException(e);
                        } finally {
                            try {
                                conn.close();
                            } catch (RepositoryException e) {
                            // Ignore
                            }
                        }
                    }
                };
            }
        } else if (query instanceof GraphQuery) {
            GraphQuery gQuery = (GraphQuery) query;
            /*
                                queryResult = gQuery.evaluate();
                                registry = RDFWriterRegistry.getInstance();
                                view = GraphQueryResultView.getInstance();
                */
            conn.close();
        } else if (query instanceof BooleanQuery) {
            BooleanQuery bQuery = (BooleanQuery) query;
            /*
                                queryResult = bQuery.evaluate();
                                registry = BooleanQueryResultWriterRegistry.getInstance();
                                view = BooleanQueryResultView.getInstance();
                */
            conn.close();
        } else {
            conn.close();
            throw new ResourceException(Status.CLIENT_ERROR_BAD_REQUEST, "Unsupported query type: " + query.getClass().getName());
        }
    } catch (RepositoryException e) {
        throw new ResourceException(Status.SERVER_ERROR_INTERNAL, e);
    } catch (QueryEvaluationException e) {
        throw new ResourceException(Status.SERVER_ERROR_INTERNAL, e);
    }
    return null;
}