MultipartRequestTest.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.stanbol.enhancer.it;

import static org.apache.stanbol.enhancer.it.MultipartContentItemTestUtils.buildPathWithParams;
import static org.apache.stanbol.enhancer.it.MultipartContentItemTestUtils.getHTMLContent;
import static org.apache.stanbol.enhancer.servicesapi.rdf.OntologicalClasses.DBPEDIA_ORGANISATION;
import static org.apache.stanbol.enhancer.servicesapi.rdf.OntologicalClasses.DBPEDIA_PERSON;
import static org.apache.stanbol.enhancer.servicesapi.rdf.OntologicalClasses.DBPEDIA_PLACE;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.charset.Charset;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.clerezza.commons.rdf.BlankNode;
import org.apache.clerezza.commons.rdf.Graph;
import org.apache.clerezza.commons.rdf.RDFTerm;
import org.apache.clerezza.commons.rdf.IRI;
import org.apache.clerezza.commons.rdf.impl.utils.PlainLiteralImpl;
import org.apache.clerezza.commons.rdf.impl.utils.simple.SimpleGraph;
import org.apache.clerezza.commons.rdf.impl.utils.TripleImpl;
import org.apache.clerezza.rdf.core.serializedform.Serializer;
import org.apache.clerezza.rdf.core.serializedform.SupportedFormat;
import org.apache.clerezza.rdf.ontologies.RDF;
import org.apache.http.HttpEntity;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.mime.MIME;
import org.apache.http.entity.mime.MultipartEntityBuilder;
import org.apache.http.entity.mime.content.AbstractContentBody;
import org.apache.http.entity.mime.content.ContentBody;
import org.apache.http.entity.mime.content.ContentDescriptor;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.message.BasicNameValuePair;
import org.apache.stanbol.enhancer.servicesapi.ContentItem;
import org.apache.stanbol.enhancer.servicesapi.EnhancementEngine;
import org.apache.stanbol.enhancer.servicesapi.helper.EnhancementEngineHelper;
import org.apache.stanbol.enhancer.servicesapi.rdf.OntologicalClasses;
import org.apache.stanbol.enhancer.servicesapi.rdf.Properties;
import org.apache.stanbol.enhancer.servicesapi.rdf.TechnicalClasses;
import org.junit.Assert;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * This tests RESTful API extensions to the Stanbol Enhancer as described by
 * STANBOL-481
 */
public class MultipartRequestTest extends EnhancerTestBase {
    private static final Charset UTF8 = Charset.forName("UTF-8");
    private static Serializer serializer = Serializer.getInstance();
    
    private static final Logger log = LoggerFactory.getLogger(MultipartRequestTest.class);

    private final String TEXT_CONTENT = "The Apache Stanbol Enhancer.\n" +
    		"The Stanbol enhancer can detect famous cities such as Paris and " +
    		"people such as Bob Marley.";
    private final String[] TEXT_CONTENT_LINES = TEXT_CONTENT.split("\n");
    private final String HTML_CONTENT = getHTMLContent(TEXT_CONTENT_LINES);
    private final String[] HTML_CONTENT_LINES = HTML_CONTENT.split("\n");
    public MultipartRequestTest() {
        super(); //use the default endpoint
    }

    @Test
    public void testIllegalRdfFormat() throws IOException {
        String[] params = new String []{
                    "outputContent","*/*",
                    "rdfFormat","notAvalidMimeFormat"};
        executor.execute(
            builder.buildPostRequest(buildPathWithParams(getEndpoint(), params))
            .withHeader("Accept","multipart/from-data")
            .withHeader("Content-Type", "text/html; charset=UTF-8")
            .withContent(HTML_CONTENT)
        )
        .assertStatus(400); //BAD_REQUEST
    }
    @Test
    public void testIllegalOutputContent() throws IOException {
        String[] params = new String []{
                    "outputContent","notAvalidMimeFormat"};
        executor.execute(
            builder.buildPostRequest(buildPathWithParams(getEndpoint(), params))
            .withHeader("Accept","multipart/from-data")
            .withHeader("Content-Type", "text/html; charset=UTF-8")
            .withContent(HTML_CONTENT)
        )
        .assertStatus(400); //BAD_REQUEST
    }
    @Test
    public void testDefaultContentTypes() throws IOException {
        //'*/*', 'text/plain' and 'application/octet-stream' where considered as
        // Indicators that the default RDF serialisation format for the metadata
        // should be used. 
        //This is basically testing backward compatibility 
        
        String[] jsonLDMetadataTests = new String[]{
            "\"@id\" : \"http://dbpedia.org/resource/Paris\",",
            "\"@id\" : \"http://dbpedia.org/resource/Bob_Marley\",",
            "\"http://purl.org/dc/terms/creator\" : [ {",
            "\"@value\" : \"org.apache.stanbol.enhancer.engines.entitytagging.impl.NamedEntityTaggingEngine\""
        };
        String[] params = new String []{
                    "outputContent","text/plain"
        };
        executor.execute(
            builder.buildPostRequest(buildPathWithParams(getEndpoint(), params))
            .withHeader("Accept","text/plain") //must be multipart/from-data
            .withHeader("Content-Type", "text/html; charset=UTF-8")
            .withContent(HTML_CONTENT)
        )
        .assertStatus(200) //metadata as JSONLD
        .assertContentContains(jsonLDMetadataTests);
        
        params = new String []{
            "outputContent","application/octet-stream"}; //omitMetadata=false
        executor.execute(
            builder.buildPostRequest(buildPathWithParams(getEndpoint(), params))
            .withHeader("Accept","text/plain") //must be multipart/from-data
            .withHeader("Content-Type", "text/html; charset=UTF-8")
            .withContent(HTML_CONTENT)
        )
        .assertStatus(200) //metadata as JSONLD
        .assertContentContains(jsonLDMetadataTests);

        params = new String []{
           "outputContent","application/octet-stream"}; //omitMetadata=false
        executor.execute(
            builder.buildPostRequest(buildPathWithParams(getEndpoint(), params))
            .withHeader("Accept","text/plain") //must be multipart/from-data
            .withHeader("Content-Type", "text/html; charset=UTF-8")
            .withContent(HTML_CONTENT)
        )
        .assertStatus(200) //metadata as JSONLD
        .assertContentContains(jsonLDMetadataTests);
    }
    
    @Test
    public void testOutputMetadataAndAllContent() throws IOException {
        String[] params = new String []{
                    "outputContent","*/*",
                    "rdfFormat","text/rdf+nt"};
        String content = executor.execute(
            builder.buildPostRequest(buildPathWithParams(getEndpoint(), params))
            .withHeader("Accept","multipart/from-data")
            .withHeader("Content-Type", "text/html; charset=UTF-8")
            .withContent(HTML_CONTENT)
        )
        .assertStatus(200)
        .assertContentContains(
            "--contentItem",
            "Content-Disposition: form-data; name=\"content\"",
            "Content-Type: multipart/alternate; boundary=contentParts-",
            "Content-Type: text/plain; charset=UTF-8",
            "Content-Type: text/html",
            "--contentParts")
        .assertContentContains(TEXT_CONTENT_LINES)
        .assertContentContains(HTML_CONTENT_LINES) //line by line the HTML content
        .assertContentRegexp(
            "Content-Disposition: form-data; name=\"metadata\"; filename=.*",
            "Content-Disposition: form-data; name=\"urn:tika:text:.*",
            "Content-Disposition: form-data; name=\"urn:content-item-sha1-.*",
            "--contentItem-.*--",
            "--contentParts-.*--",
            //and the expected enhancements in the metadata
            "http://purl.org/dc/terms/creator.*LanguageDetectionEnhancementEngine",
            "http://purl.org/dc/terms/language.*en",
            "http://fise.iks-project.eu/ontology/entity-label.*Paris",
            "http://purl.org/dc/terms/creator.*org.apache.stanbol.enhancer.engines.opennlp.*NamedEntityExtractionEnhancementEngine",
            "http://fise.iks-project.eu/ontology/entity-label.*Bob Marley")
        .getContent();
        log.debug("Content:\n{}\n",content);

    }
    @Test
    public void testOutputAllContentOmitMetadata() throws IOException {
        String[] params = new String []{
                    "outputContent","*/*",
                    "omitMetadata","true",
                    "rdfFormat","text/rdf+nt"};
        String content = executor.execute(
            builder.buildPostRequest(buildPathWithParams(getEndpoint(), params))
            .withHeader("Accept","multipart/from-data")
            .withHeader("Content-Type", "text/html; charset=UTF-8")
            .withContent(HTML_CONTENT)
        )
        .assertStatus(200)
        .assertContentContains(
            "--contentItem",
            "Content-Disposition: form-data; name=\"content\"",
            "Content-Type: multipart/alternate; boundary=contentParts-",
            "Content-Type: text/plain; charset=UTF-8",
            "Content-Type: text/html",
            "--contentParts")
        .assertContentContains(TEXT_CONTENT_LINES)
        .assertContentContains(HTML_CONTENT_LINES) //line by line the HTML content
        .assertContentRegexp( //MUST contain
            "--contentItem-.*--",
            "--contentParts-.*--",
            "Content-Disposition: form-data; name=\"urn:tika:text:.*",
            "Content-Disposition: form-data; name=\"urn:content-item-sha1-.*")
        .assertContentRegexp(false, //MUST NOT contain
            "Content-Disposition: form-data; name=\"metadata\"; filename=.*",
            //and the expected enhancements in the metadata
            "http://purl.org/dc/terms/creator.*LanguageDetectionEnhancementEngine",
            "http://purl.org/dc/terms/language.*en",
            "http://fise.iks-project.eu/ontology/entity-label.*Paris",
            "http://purl.org/dc/terms/creator.*org.apache.stanbol.enhancer.engines.opennlp.*NamedEntityExtractionEnhancementEngine",
            "http://fise.iks-project.eu/ontology/entity-label.*Bob Marley")
        .getContent();
        log.debug("Content:\n{}\n",content);

    }

    @Test
    public void testOutputPlainTextContent() throws IOException {
        String[] params = new String []{
                    "outputContent","text/plain",
                    "rdfFormat","text/rdf+nt"};
        String content = executor.execute(
            builder.buildPostRequest(buildPathWithParams(getEndpoint(), params))
            .withHeader("Accept","multipart/from-data")
            .withHeader("Content-Type", "text/html; charset=UTF-8")
            .withContent(HTML_CONTENT)
        )
        .assertStatus(200)
        .assertContentContains(
            "--contentItem",
            "Content-Disposition: form-data; name=\"content\"",
            "Content-Type: multipart/alternate; boundary=contentParts-",
            "Content-Type: text/plain; charset=UTF-8",
            "--contentParts")
        .assertContentContains(TEXT_CONTENT_LINES)
        .assertContentRegexp(
            "--contentItem-.*--",
            "--contentParts-.*--",
            "Content-Disposition: form-data; name=\"metadata\"; filename=.*",
            "Content-Disposition: form-data; name=\"urn:tika:text:.*",
            //and the expected enhancements in the metadata
            "http://purl.org/dc/terms/creator.*LanguageDetectionEnhancementEngine",
            "http://purl.org/dc/terms/language.*en",
            "http://fise.iks-project.eu/ontology/entity-label.*Paris",
            "http://purl.org/dc/terms/creator.*org.apache.stanbol.enhancer.engines.opennlp.*NamedEntityExtractionEnhancementEngine",
            "http://fise.iks-project.eu/ontology/entity-label.*Bob Marley")
        .getContent();
        log.debug("Content:\n{}\n",content);

    }
    @Test
    public void testOutputContentOtherThanParsed() throws IOException {
        //metadata and text content
        String[] params = new String []{
                    "outputContent","*/*",
                    "omitParsed","true",
                    "rdfFormat","text/rdf+nt"};
        String content = executor.execute(
            builder.buildPostRequest(buildPathWithParams(getEndpoint(), params))
            .withHeader("Accept","multipart/from-data")
            .withHeader("Content-Type", "text/html; charset=UTF-8")
            .withContent(HTML_CONTENT)
        )
        .assertStatus(200)
        .assertContentContains(
             "--contentItem",
             "Content-Disposition: form-data; name=\"content\"",
             "Content-Type: multipart/alternate; boundary=contentParts-",
             "Content-Type: text/plain; charset=UTF-8",
             "--contentParts")
         .assertContentContains(TEXT_CONTENT_LINES)
         .assertContentRegexp(
             "--contentItem-.*--",
             "--contentParts-.*--",
             "Content-Disposition: form-data; name=\"metadata\"; filename=.*",
             "Content-Disposition: form-data; name=\"urn:tika:text:.*",
             //and the expected enhancements in the metadata
             "http://purl.org/dc/terms/creator.*LanguageDetectionEnhancementEngine",
             "http://purl.org/dc/terms/language.*en",
             "http://fise.iks-project.eu/ontology/entity-label.*Paris",
             "http://purl.org/dc/terms/creator.*org.apache.stanbol.enhancer.engines.opennlp.*NamedEntityExtractionEnhancementEngine",
             "http://fise.iks-project.eu/ontology/entity-label.*Bob Marley")
         .getContent();
        log.debug("Content:\n{}\n",content);
    }
    @Test
    public void testOutputContentPart() throws IOException {
        String[] params = new String []{
                    "outputContentPart","http://stanbol.apache.org/ontology/enhancer/executionmetadata#ChainExecution",
                    "omitMetadata","true",
                    "rdfFormat","application/rdf+xml"};
        String content = executor.execute(
            builder.buildPostRequest(buildPathWithParams(getEndpoint(), params))
            .withHeader("Accept","multipart/from-data")
            .withHeader("Content-Type", "text/plain; charset=UTF-8")
            .withContent(TEXT_CONTENT)
        )
        .assertStatus(200)
        .assertContentContains(
             "--contentItem",
             "Content-Disposition: form-data; name=\"http://stanbol.apache.org/ontology/enhancer/executionmetadata#ChainExecution\"",
             "Content-Type: application/rdf+xml; charset=UTF-8",
             "<rdf:type rdf:resource=\"http://stanbol.apache.org/ontology/enhancer/executionplan#ExecutionPlan\"/>",
             "<rdf:type rdf:resource=\"http://stanbol.apache.org/ontology/enhancer/executionplan#ExecutionNode\"/>",
             "<rdf:type rdf:resource=\"http://stanbol.apache.org/ontology/enhancer/executionmetadata#EngineExecution\"/>",
             "<rdf:type rdf:resource=\"http://stanbol.apache.org/ontology/enhancer/executionmetadata#ChainExecution\"/>")
        .assertContentRegexp("--contentItem-.*--")
        .getContent();
        log.debug("Content:\n{}\n",content);
    }
    /**
     * This uploads the HTML as well as the plain text version of an content.
     * This allows it CMS to parse already available alternate content versions
     * in a single request. Stanbol can than still use the original content
     * (e.g. to extract metadata) but other engines that require the alternate
     * version (e.g. plain text version) of an document will directly use the
     * parsed version .<p>
     * This UnitTest ensures this by adding a "secret" extension the to plain
     * text version and than checks if the two entities mentioned in that
     * part are included in the extracted entities.
     * @throws IOException
     */
    @Test
    public void testUploadMultipleContents() throws IOException {
        //It is a secret, that Berlin is the capital of Germany
        String extraTextConent = TEXT_CONTENT + 
                "\nIt is a secret, that the city of Berlin is the capital of Germany since 1990.";
        //The multipartBuilder used to construct the contentItem for the contentItem
        MultipartEntityBuilder ciBuilder = MultipartEntityBuilder.create();
        String boundary = "contentItem-47jjksnbue73fnis";
        ciBuilder.setBoundary(boundary);
        //use a small extension to deal with multipart/alternate
        Map<String, ContentBody> alternates = new LinkedHashMap<String,ContentBody>();
        alternates.put("http://www.example.com/test.html", 
            new StringBody(HTML_CONTENT, ContentType.TEXT_HTML.withCharset(UTF8)));
        alternates.put("http://www.example.com/test.txt", 
            new StringBody(extraTextConent, ContentType.TEXT_PLAIN.withCharset(UTF8)));
        ciBuilder.addPart("content", 
            new MultipartContentBody(alternates, "contentParts", 
                ContentType.create("multipart/alternate")));
        
        String receivedContent = executor.execute(
            builder.buildPostRequest(getEndpoint())
            .withHeader("Accept","text/rdf+nt")
            .withEntity(ciBuilder.build())
        )
        .assertStatus(200)
        .assertContentRegexp(
            //and the expected enhancements in the metadata
            "http://purl.org/dc/terms/creator.*LanguageDetectionEnhancementEngine",
            "http://purl.org/dc/terms/language.*en",
            "http://fise.iks-project.eu/ontology/entity-label.*Paris",
            "http://purl.org/dc/terms/creator.*org.apache.stanbol.enhancer.engines.opennlp.*NamedEntityExtractionEnhancementEngine",
            "http://fise.iks-project.eu/ontology/entity-label.*Bob Marley",
            //check also for expeted entities extracted from the secret Text part!
            "http://fise.iks-project.eu/ontology/entity-label.*Berlin",
            "http://fise.iks-project.eu/ontology/entity-label.*Germany")
        .getContent();
        log.debug("Content:\n{}\n",receivedContent);

    }
    
    
    @Test
    public void testContentBeforeMetadata() throws IOException{
        final IRI contentItemId = new IRI("http://www.example.com/test.html");
        String rdfContentType = SupportedFormat.RDF_XML;
        String rdfContent = getDummyRdfMetadata(contentItemId, rdfContentType);
        MultipartEntityBuilder ciBuilder = MultipartEntityBuilder.create();
        ciBuilder.addTextBody("content",HTML_CONTENT,ContentType.TEXT_HTML.withCharset(UTF8));
        ciBuilder.addTextBody("metadata", rdfContent, ContentType.create(rdfContentType,UTF8));
        String receivedContent = executor.execute(
            builder.buildPostRequest(getEndpoint())
            .withHeader("Accept","text/rdf+nt")
            .withEntity(ciBuilder.build())
        )
        .assertStatus(400) //BAD request
        .getContent();
        //check also the error message
        Assert.assertTrue(receivedContent.contains(
            "The Multipart MIME part with the 'metadata' MUST BE before the " +
            "MIME part containing the 'content'"));
    }
    @Test
    public void testMissingContent() throws IOException{
        final IRI contentItemId = new IRI("http://www.example.com/test.html");
        String rdfContentType = SupportedFormat.RDF_XML;
        String rdfContent = getDummyRdfMetadata(contentItemId, rdfContentType);
        MultipartEntityBuilder ciBuilder = MultipartEntityBuilder.create();
        ciBuilder.addTextBody("metadata", rdfContent, ContentType.create(rdfContentType,UTF8));

        String receivedContent = executor.execute(
            builder.buildPostRequest(getEndpoint())
            .withHeader("Accept","text/rdf+nt")
            .withEntity(ciBuilder.build())
        )
        .assertStatus(400) //BAD request
        .getContent();
        //check also the error message
        Assert.assertTrue(receivedContent.contains(
            "The parsed multipart content item does not contain any content."));
    }

    /**
     * @param contentItemId
     * @param rdfContentType
     * @return
     */
    private String getDummyRdfMetadata(final IRI contentItemId, String rdfContentType) {
        Graph metadata = new SimpleGraph();
        metadata.add(new TripleImpl(new BlankNode(), Properties.ENHANCER_EXTRACTED_FROM, contentItemId));
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        serializer.serialize(out, metadata, rdfContentType);
        String rdfContent = new String(out.toByteArray(),UTF8);
        return rdfContent;
    }
    
    /**
     * Stanbol also supports to upload pre-existing metadata with the content.
     * This UnitTest uses an example that parsed TextAnnotations for free text
     * tags provided by users that are than linked to Entities in DBPedia
     * @throws IOException
     */
    @Test
    public void testUploadWithMetadata() throws IOException {
        //create the metadata
        RDFTerm user = new PlainLiteralImpl("Rupert Westenthaler");
        final IRI contentItemId = new IRI("http://www.example.com/test.html");
        Graph metadata = new SimpleGraph();
        addTagAsTextAnnotation(metadata, contentItemId, 
            "Germany",DBPEDIA_PLACE, user);
        addTagAsTextAnnotation(metadata, contentItemId, 
            "Europe",DBPEDIA_PLACE, user);
        addTagAsTextAnnotation(metadata, contentItemId, 
            "NATO",DBPEDIA_ORGANISATION, user);
        addTagAsTextAnnotation(metadata, contentItemId, 
            "Silvio Berlusconi",DBPEDIA_PERSON, user);
        
        String rdfContentType = SupportedFormat.RDF_XML;
        
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        serializer.serialize(out, metadata, rdfContentType);
        String rdfContent = new String(out.toByteArray(),UTF8);
        
        MultipartEntityBuilder ciBuilder = MultipartEntityBuilder.create();
        //add the metadata
        /*
         * NOTE: We need here to override the getFilename, because this MUST
         *       BE the URI of the ContentItem. This is important, because the
         *       Metadata do contain triples about that ContentItem and therefore
         *       it MUST BE assured that the URI of the ContentItem created by
         *       the Stanbol Enhancer is the same of as the URI used in the
         *       Metadata!
         */
        ciBuilder.addPart("metadata", 
            new StringBody(rdfContent, ContentType.create(rdfContentType).withCharset(UTF8)){
            @Override
            public String getFilename() { //The filename MUST BE the
                return contentItemId.getUnicodeString(); //uri of the ContentItem
            }
        });
        //add the content
        ciBuilder.addTextBody("content", HTML_CONTENT, ContentType.TEXT_HTML.withCharset(UTF8));        
        //send the request
        String receivedContent = executor.execute(
            builder.buildPostRequest(getEndpoint())
            .withHeader("Accept","text/rdf+nt")
            .withEntity(ciBuilder.build())
        )
        .assertStatus(200)
        .assertContentRegexp(
            //and the expected enhancements based on the parsed content
            "http://purl.org/dc/terms/creator.*LanguageDetectionEnhancementEngine",
            "http://purl.org/dc/terms/language.*en",
            "http://fise.iks-project.eu/ontology/entity-label.*Paris",
            "http://purl.org/dc/terms/creator.*org.apache.stanbol.enhancer.engines.opennlp.*NamedEntityExtractionEnhancementEngine",
            "http://fise.iks-project.eu/ontology/entity-label.*Bob Marley",
            //additional enhancements based on parsed metadata
            "http://fise.iks-project.eu/ontology/entity-reference.*http://dbpedia.org/resource/Germany.*",
            "http://fise.iks-project.eu/ontology/entity-reference.*http://dbpedia.org/resource/NATO.*",
            "http://fise.iks-project.eu/ontology/entity-reference.*http://dbpedia.org/resource/Silvio_Berlusconi.*",
            "http://fise.iks-project.eu/ontology/entity-reference.*http://dbpedia.org/resource/Europe.*")
        .getContent();
        log.debug("Content:\n{}\n",receivedContent);
    }
    /**
     * Utility that creates an {@link TechnicalClasses#ENHANCER_TEXTANNOTATION TextAnnotation}
     * for the parsed contentItem, free text tag an user. 
     * @param graph the grpah to add the information
     * @param contentItem the {@link ContentItem#getUri() uri} of the {@link ContentItem}
     * @param tag the free text tag for the document
     * @param tagType the type of the tag. Typically Stanbol supports: <ul>
     * <li>{@link OntologicalClasses#DBPEDIA_PERSON}
     * <li>{@link OntologicalClasses#DBPEDIA_ORGANISATION}
     * <li>{@link OntologicalClasses#DBPEDIA_PLACE}
     * </ul>
     * But specific {@link EnhancementEngine}s might also process other types
     * or even TextAnnotations without an type
     * @param user the user that created the tag
     * @return the uri of the created annotation
     */
    private static final IRI addTagAsTextAnnotation(Graph graph, IRI contentItem, 
                                                       String tag, IRI tagType, RDFTerm user){
        IRI ta = new IRI("urn:user-annotation:"+EnhancementEngineHelper.randomUUID());
        graph.add(new TripleImpl(ta, RDF.type, TechnicalClasses.ENHANCER_TEXTANNOTATION));
        graph.add(new TripleImpl(ta, Properties.ENHANCER_EXTRACTED_FROM,contentItem));
        if(tagType != null){
            graph.add(new TripleImpl(ta, Properties.DC_TYPE, tagType));
        }
        graph.add(new TripleImpl(ta, Properties.ENHANCER_SELECTED_TEXT, new PlainLiteralImpl(tag)));
        graph.add(new TripleImpl(ta, RDF.type, TechnicalClasses.ENHANCER_ENHANCEMENT));
        if(user != null){
            graph.add(new TripleImpl(ta, Properties.DC_CREATOR,user));
        }
        return ta;
    }    
    /**
     * Supports sending multipart mime as {@link ContentBody}.
     * @author Rupert Westenthaler
     *
     */
    private class MultipartContentBody extends AbstractContentBody implements ContentBody,ContentDescriptor {

        private Map<String,ContentBody> parts;
        private String boundary;

        public MultipartContentBody(Map<String,ContentBody> parts, String boundary, ContentType contentType){
            super(ContentType.create(contentType.getMimeType(), new BasicNameValuePair("boundary",boundary)));
            this.parts = parts;
            this.boundary = boundary;
        }

        @Override
        public String getTransferEncoding() {
            return MIME.ENC_8BIT;
        }

        @Override
        public long getContentLength() {
            //not known as we would need to count the content length AND
            //the length of the different mime headers.
            return -1; 
        }

        @Override
        public String getFilename() {
            return null;
        }

        @Override
        public void writeTo(OutputStream out) throws IOException {
            MultipartEntityBuilder builder = MultipartEntityBuilder.create();
            builder.setBoundary(boundary);
            for(Entry<String,ContentBody> part : parts.entrySet()){
                builder.addPart(part.getKey(), part.getValue());
            }
            HttpEntity entity = builder.build();
            entity.writeTo(out);
        }
        
    }

}