Example usage for org.apache.http.protocol HTTP CONTENT_TYPE

List of usage examples for org.apache.http.protocol HTTP CONTENT_TYPE

Introduction

In this page you can find the example usage for org.apache.http.protocol HTTP CONTENT_TYPE.

Prototype

String CONTENT_TYPE

To view the source code for org.apache.http.protocol HTTP CONTENT_TYPE.

Click Source Link

Usage

From source file:ai.eve.volley.stack.HurlStack.java

private static void addBodyIfExists(HttpURLConnection connection, Request<?> request)
        throws IOException, AuthFailureError {
    connection.setDoOutput(true);//from w  w w.j a v a 2s  .c  o m
    connection.setRequestProperty("connection", "Keep-Alive");
    connection.addRequestProperty(HTTP.CONTENT_TYPE, request.getBodyContentType());
    request.getBody(connection);
}

From source file:com.azure.webapi.MobileServiceJsonTable.java

/**
 * Inserts a JsonObject into a Mobile Service Table
 * //from   w  w  w  .ja v a 2 s . c  om
 * @param element
 *            The JsonObject to insert
 * @param parameters
 *            A list of user-defined parameters and values to include in the request URI query string
 * @param callback
 *            Callback to invoke when the operation is completed
 * @throws InvalidParameterException
 */
public void insert(final JsonObject element, List<Pair<String, String>> parameters,
        final TableJsonOperationCallback callback) {

    try {
        removeIdFromJson(element);
    } catch (InvalidParameterException e) {
        if (callback != null) {
            callback.onCompleted(null, e, null);
        }
        return;
    }

    String content = element.toString();

    ServiceFilterRequest post;
    try {
        Uri.Builder uriBuilder = Uri.parse(mClient.getAppUrl().toString()).buildUpon();
        uriBuilder.path(TABLES_URL);
        uriBuilder.appendPath(URLEncoder.encode(mTableName, MobileServiceClient.UTF8_ENCODING));

        if (parameters != null && parameters.size() > 0) {
            for (Pair<String, String> parameter : parameters) {
                uriBuilder.appendQueryParameter(parameter.first, parameter.second);
            }
        }
        post = new ServiceFilterRequestImpl(new HttpPost(uriBuilder.build().toString()));
        post.addHeader(HTTP.CONTENT_TYPE, MobileServiceConnection.JSON_CONTENTTYPE);

    } catch (UnsupportedEncodingException e) {
        if (callback != null) {
            callback.onCompleted(null, e, null);
        }
        return;
    }

    try {
        post.setContent(content);
    } catch (Exception e) {
        if (callback != null) {
            callback.onCompleted(null, e, null);
        }
        return;
    }

    executeTableOperation(post, new TableJsonOperationCallback() {

        @Override
        public void onCompleted(JsonObject jsonEntity, Exception exception, ServiceFilterResponse response) {
            if (callback != null) {
                if (exception == null && jsonEntity != null) {
                    JsonObject patchedJson = patchOriginalEntityWithResponseEntity(element, jsonEntity);

                    callback.onCompleted(patchedJson, exception, response);
                } else {
                    callback.onCompleted(jsonEntity, exception, response);
                }
            }
        }
    });
}

From source file:com.spoiledmilk.ibikecph.util.HttpUtils.java

public static JsonNode deleteFromServer(String urlString, JSONObject objectToPost) {
    JsonNode ret = null;//w  ww.  ja va 2s. c o m
    LOG.d("DELETE api request, url = " + urlString);
    HttpParams myParams = new BasicHttpParams();
    HttpConnectionParams.setConnectionTimeout(myParams, CONNECTON_TIMEOUT);
    HttpConnectionParams.setSoTimeout(myParams, CONNECTON_TIMEOUT);
    HttpClient httpclient = new DefaultHttpClient(myParams);
    httpclient.getParams().setParameter(CoreProtocolPNames.USER_AGENT, Config.USER_AGENT);
    HTTPDeleteWithBody httpdelete = null;
    URL url = null;
    try {
        url = new URL(urlString);
        httpdelete = new HTTPDeleteWithBody(url.toString());
        httpdelete.setHeader("Content-type", "application/json");
        httpdelete.setHeader("Accept", ACCEPT);
        httpdelete.setHeader("LANGUAGE_CODE", IbikeApplication.getLanguageString());
        StringEntity se = new StringEntity(objectToPost.toString(), HTTP.UTF_8);
        se.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
        httpdelete.setEntity(se);
        HttpResponse response = httpclient.execute(httpdelete);
        String serverResponse = EntityUtils.toString(response.getEntity());
        LOG.d("API response = " + serverResponse);
        ret = Util.stringToJsonNode(serverResponse);
    } catch (Exception e) {
        if (e != null && e.getLocalizedMessage() != null)
            LOG.e(e.getLocalizedMessage());
    }
    return ret;
}

From source file:org.apache.synapse.rest.Resource.java

@Override
boolean canProcess(MessageContext synCtx) {
    if (synCtx.isResponse()) {
        return true;
    }//from  w w  w .j  a va2 s.c  o m

    org.apache.axis2.context.MessageContext msgCtx = ((Axis2MessageContext) synCtx).getAxis2MessageContext();
    if (protocol == RESTConstants.PROTOCOL_HTTP_ONLY
            && !Constants.TRANSPORT_HTTP.equals(msgCtx.getIncomingTransportName())) {
        if (log.isDebugEnabled()) {
            log.debug("Protocol information does not match - Expected HTTP");
        }
        return false;
    }

    if (protocol == RESTConstants.PROTOCOL_HTTPS_ONLY
            && !Constants.TRANSPORT_HTTPS.equals(msgCtx.getIncomingTransportName())) {
        if (log.isDebugEnabled()) {
            log.debug("Protocol information does not match - Expected HTTPS");
        }
        return false;
    }

    String method = (String) msgCtx.getProperty(Constants.Configuration.HTTP_METHOD);
    synCtx.setProperty(RESTConstants.REST_METHOD, method);

    if (RESTConstants.METHOD_OPTIONS.equals(method)) {
        return true; // OPTIONS requests are always welcome
    } else if (!methods.isEmpty()) {
        if (!methods.contains(method)) {
            if (log.isDebugEnabled()) {
                log.debug("HTTP method does not match");
            }
            return false;
        }
    }

    Map transportHeaders = (Map) msgCtx.getProperty(org.apache.axis2.context.MessageContext.TRANSPORT_HEADERS);
    if ((contentType != null || userAgent != null) && transportHeaders == null) {
        if (log.isDebugEnabled()) {
            log.debug("Transport headers not available on the message");
        }
        return false;
    }

    boolean hasPayload = !Boolean.TRUE.equals(msgCtx.getProperty(NhttpConstants.NO_ENTITY_BODY));
    if (contentType != null && hasPayload) {
        String type = (String) transportHeaders.get(HTTP.CONTENT_TYPE);
        if (!contentType.equals(type)) {
            if (log.isDebugEnabled()) {
                log.debug("Content type does not match - Expected: " + contentType + ", " + "Found: " + type);
            }
            return false;
        }
    }

    if (userAgent != null) {
        String agent = (String) transportHeaders.get(HTTP.USER_AGENT);
        if (agent == null || !agent.matches(this.userAgent)) {
            if (log.isDebugEnabled()) {
                log.debug("User agent does not match - Expected: " + userAgent + ", " + "Found: " + agent);
            }
            return false;
        }
    }

    return true;
}

From source file:com.intellij.tasks.impl.TaskUtil.java

public static void prettyFormatResponseToLog(@Nonnull Logger logger, @Nonnull HttpMethod response) {
    if (logger.isDebugEnabled() && response.hasBeenUsed()) {
        try {//from  www . ja va  2 s . co  m
            String content = ResponseUtil.getResponseContentAsString(response);
            Header header = response.getRequestHeader(HTTP.CONTENT_TYPE);
            String contentType = header == null ? "text/plain"
                    : header.getElements()[0].getName().toLowerCase(Locale.ENGLISH);
            if (contentType.contains("xml")) {
                prettyFormatXmlToLog(logger, content);
            } else if (contentType.contains("json")) {
                prettyFormatJsonToLog(logger, content);
            } else {
                logger.debug(content);
            }
        } catch (IOException e) {
            logger.error(e);
        }
    }
}

From source file:org.wso2.carbon.core.transports.CarbonServlet.java

private void processWithGetProcessor(HttpServletRequest request, HttpServletResponse response, String item)
        throws Exception {
    OverflowBlob temporaryData = new OverflowBlob(256, 4048, "_servlet", ".dat");
    try {//  w w w  .j a va  2  s .c o  m
        CarbonHttpRequest carbonHttpRequest = new CarbonHttpRequest("GET", request.getRequestURI(),
                request.getRequestURL().toString());

        Enumeration names = request.getParameterNames();
        while (names.hasMoreElements()) {
            Object name = names.nextElement();
            if (name != null && name instanceof String) {
                carbonHttpRequest.setParameter((String) name, request.getParameter((String) name));
            }
        }

        carbonHttpRequest.setContextPath(request.getContextPath());
        carbonHttpRequest.setQueryString(request.getQueryString());

        CarbonHttpResponse carbonHttpResponse = new CarbonHttpResponse(temporaryData.getOutputStream());

        (getRequestProcessors.get(item)).process(carbonHttpRequest, carbonHttpResponse, configContext);

        // adding headers
        Map responseHeaderMap = carbonHttpResponse.getHeaders();
        for (Object obj : responseHeaderMap.entrySet()) {
            Map.Entry entry = (Map.Entry) obj;
            response.setHeader(entry.getKey().toString(), entry.getValue().toString());
        }

        // setting status code
        response.setStatus(carbonHttpResponse.getStatusCode());

        // setting error codes
        if (carbonHttpResponse.isError()) {
            if (carbonHttpResponse.getStatusMessage() != null) {
                response.sendError(carbonHttpResponse.getStatusCode(), carbonHttpResponse.getStatusMessage());
            } else {
                response.sendError(carbonHttpResponse.getStatusCode());
            }
        }

        if (carbonHttpResponse.isRedirect()) {
            response.sendRedirect(carbonHttpResponse.getRedirect());
        }

        if (carbonHttpResponse.getHeaders().get(HTTP.CONTENT_TYPE) != null) {
            response.setContentType(carbonHttpResponse.getHeaders().get(HTTP.CONTENT_TYPE));
        }

        temporaryData.writeTo(response.getOutputStream());
    } finally {
        temporaryData.release();
    }
}

From source file:org.alfresco.test.util.SiteService.java

/**
 * Set site as favorite/* w ww  .  j  a  v  a2 s.com*/
 * 
 * @param userName String identifier
 * @param password
 * @param siteName
 * @return true if marked as favorite
 * @throws Exception if error
 */
public boolean setFavorite(final String userName, final String password, final String siteName)
        throws Exception {
    if (StringUtils.isEmpty(userName) || StringUtils.isEmpty(password) || StringUtils.isEmpty(siteName)) {
        throw new IllegalArgumentException("Parameter missing");
    }
    AlfrescoHttpClient client = alfrescoHttpClientFactory.getObject();
    String nodeRef = getSiteNodeRef(userName, password, siteName);
    String reqUrl = client.getApiVersionUrl() + "people/" + userName + "/favorites";
    HttpPost post = new HttpPost(reqUrl);
    String jsonInput;
    jsonInput = "{\"target\": {\"" + "site" + "\" : {\"guid\" : \"" + nodeRef + "\"}}}";
    StringEntity se = new StringEntity(jsonInput.toString(), AlfrescoHttpClient.UTF_8_ENCODING);
    se.setContentType(new BasicHeader(HTTP.CONTENT_TYPE, AlfrescoHttpClient.MIME_TYPE_JSON));
    post.setEntity(se);
    HttpClient clientWithAuth = client.getHttpClientWithBasicAuth(userName, password);
    try {
        HttpResponse response = clientWithAuth.execute(post);
        switch (response.getStatusLine().getStatusCode()) {
        case HttpStatus.SC_CREATED:
            return true;
        case HttpStatus.SC_NOT_FOUND:
            throw new RuntimeException("Site doesn't exists " + siteName);
        case HttpStatus.SC_UNAUTHORIZED:
            throw new RuntimeException("Invalid user name or password");
        default:
            logger.error("Unable to mark as favorite: " + response.toString());
            break;
        }
    } finally {
        post.releaseConnection();
        client.close();
    }
    return false;
}

From source file:org.wso2.carbon.http2.transport.util.Http2TargetRequestUtil.java

/**
 * Extracts necessary headers for http2 request
 *
 * @param msgContext/* w  ww.  ja v a2  s .c  om*/
 * @return
 * @throws AxisFault
 */
public Http2Headers getHeaders(MessageContext msgContext) throws AxisFault {
    Http2Headers http2Headers = new DefaultHttp2Headers();
    Map<String, String> reqeustHeaders = new TreeMap<>();

    String httpMethod = (String) msgContext.getProperty(Constants.Configuration.HTTP_METHOD);
    if (httpMethod == null) {
        httpMethod = "POST";
    }
    reqeustHeaders.put(Http2Headers.PseudoHeaderName.METHOD.value().toString(), httpMethod);

    EndpointReference epr = PassThroughTransportUtils.getDestinationEPR(msgContext);
    String targetEPR = epr.getAddress();
    if (targetEPR.toLowerCase().contains("http2://")) {
        targetEPR = targetEPR.replaceFirst("http2://", "http://");
    } else if (targetEPR.toLowerCase().contains("https2://")) {
        targetEPR = targetEPR.replaceFirst("https2://", "https://");
    }
    epr.setAddress(targetEPR);
    URL url = null;
    try {
        url = new URL(epr.getAddress());
    } catch (MalformedURLException e) {
        throw new AxisFault("endpoint url parsing failed : ", e);
    }
    //this code block is needed to replace the host header in service chaining with REQUEST_HOST_HEADER
    //adding host header since it is not available in response message.
    //otherwise Host header will not replaced after first call
    if (msgContext.getProperty(NhttpConstants.REQUEST_HOST_HEADER) != null) {
        Object headers = msgContext.getProperty(MessageContext.TRANSPORT_HEADERS);
        if (headers != null) {
            Map headersMap = (Map) headers;
            if (!headersMap.containsKey(HTTPConstants.HEADER_HOST)) {
                headersMap.put(HttpHeaderNames.HOST,
                        msgContext.getProperty(NhttpConstants.REQUEST_HOST_HEADER));
            }
        }
    }

    // headers
    PassThroughTransportUtils.removeUnwantedHeaders(msgContext, configuration);

    Object o = msgContext.getProperty(MessageContext.TRANSPORT_HEADERS);

    if (o != null && o instanceof Map) {
        Map headers = (Map) o;
        for (Object entryObj : headers.entrySet()) {
            Map.Entry entry = (Map.Entry) entryObj;
            if (entry.getValue() != null && entry.getKey() instanceof String
                    && entry.getValue() instanceof String) {
                if (HTTPConstants.HEADER_HOST.equalsIgnoreCase((String) entry.getKey())
                        && !configuration.isPreserveHttpHeader(HTTPConstants.HEADER_HOST)) {
                    if (msgContext.getProperty(NhttpConstants.REQUEST_HOST_HEADER) != null) {
                        reqeustHeaders.put(((String) entry.getKey()).toLowerCase(),
                                (String) msgContext.getProperty(NhttpConstants.REQUEST_HOST_HEADER));
                    }

                } else {
                    if (!defaultHttp2Headers.contains(entry.getKey()))
                        reqeustHeaders.put(((String) entry.getKey()).toLowerCase(), (String) entry.getValue());
                    else {
                        String keyV = ":" + entry.getKey().toString().toLowerCase();
                        reqeustHeaders.put(keyV, (String) entry.getValue());
                    }
                }
            }
        }
    }

    String cType = null;
    try {
        cType = getContentType(msgContext, configuration.isPreserveHttpHeader(HTTP.CONTENT_TYPE));
    } catch (AxisFault axisFault) {
        axisFault.printStackTrace();
    }
    if (cType != null && (!httpMethod.equals("GET") && !httpMethod.equals("DELETE"))) {
        String messageType = (String) msgContext.getProperty("messageType");
        if (messageType != null) {
            boolean builderInvoked = false;
            final Pipe pipe = (Pipe) msgContext.getProperty(PassThroughConstants.PASS_THROUGH_PIPE);
            if (pipe != null) {
                builderInvoked = Boolean.TRUE
                        .equals(msgContext.getProperty(PassThroughConstants.MESSAGE_BUILDER_INVOKED));
            }

            // if multipart related message type and unless if message
            // not get build we should
            // skip of setting formatter specific content Type
            if (messageType.indexOf(HTTPConstants.MEDIA_TYPE_MULTIPART_RELATED) == -1
                    && messageType.indexOf(HTTPConstants.MEDIA_TYPE_MULTIPART_FORM_DATA) == -1) {
                Map msgCtxheaders = (Map) o;
                if (msgCtxheaders != null && !cType.isEmpty()) {
                    msgCtxheaders.put(HTTP.CONTENT_TYPE, cType);
                }
                reqeustHeaders.put(HttpHeaderNames.CONTENT_TYPE.toString(), cType);
            }

            // if messageType is related to multipart and if message
            // already built we need to set new
            // boundary related content type at Content-Type header
            if (builderInvoked && (((messageType.indexOf(HTTPConstants.MEDIA_TYPE_MULTIPART_RELATED) != -1)
                    || (messageType.indexOf(HTTPConstants.MEDIA_TYPE_MULTIPART_FORM_DATA) != -1)))) {
                reqeustHeaders.put(HttpHeaderNames.CONTENT_TYPE.toString(), cType);
            }

        } else {
            reqeustHeaders.put(HttpHeaderNames.CONTENT_TYPE.toString(), cType);
        }

    }

    // version
    String forceHttp10 = (String) msgContext.getProperty(PassThroughConstants.FORCE_HTTP_1_0);
    if ("true".equals(forceHttp10)) {
        //request.setVersion(HttpVersion.HTTP_1_0);
    }

    // keep alive
    String noKeepAlie = (String) msgContext.getProperty(PassThroughConstants.NO_KEEPALIVE);
    if ("true".equals(noKeepAlie)) {
        keepAlive = false;
    }

    // port
    port = url.getPort();

    // chunk
    String disableChunking = (String) msgContext.getProperty(PassThroughConstants.DISABLE_CHUNKING);
    if ("true".equals(disableChunking)) {
        disableChunk = true;
    }

    // full url
    String fullUr = (String) msgContext.getProperty(PassThroughConstants.FULL_URI);
    if ("true".equals(fullUr)) {
        fullUrl = true;
    }

    // Add excess respsonse header.
    String excessProp = NhttpConstants.EXCESS_TRANSPORT_HEADERS;
    Map excessHeaders = (Map) msgContext.getProperty(excessProp);
    if (excessHeaders != null) {
        for (Iterator iterator = excessHeaders.keySet().iterator(); iterator.hasNext();) {
            String key = (String) iterator.next();
            for (String excessVal : (Collection<String>) excessHeaders.get(key)) {
                reqeustHeaders.put(key.toLowerCase(), (String) excessVal);
            }
        }
    }
    String path = fullUrl || (route.getProxyHost() != null && !route.isTunnelled()) ? url.toString()
            : url.getPath() + (url.getQuery() != null ? "?" + url.getQuery() : "");

    if ((("GET").equals(msgContext.getProperty(Constants.Configuration.HTTP_METHOD)))
            || (("DELETE").equals(msgContext.getProperty(Constants.Configuration.HTTP_METHOD)))) {
        try {
            hasEntityBody = false;
            MessageFormatter formatter = MessageProcessorSelector.getMessageFormatter(msgContext);
            OMOutputFormat format = PassThroughTransportUtils.getOMOutputFormat(msgContext);
            if (formatter != null && format != null) {
                URL _url = formatter.getTargetAddress(msgContext, format, url);
                if (_url != null && !_url.toString().isEmpty()) {
                    if (msgContext.getProperty(NhttpConstants.POST_TO_URI) != null && Boolean.TRUE.toString()
                            .equals(msgContext.getProperty(NhttpConstants.POST_TO_URI))) {
                        path = _url.toString();
                    } else {
                        path = _url.getPath() + ((_url.getQuery() != null && !_url.getQuery().isEmpty())
                                ? ("?" + _url.getQuery())
                                : "");
                    }

                }
                if (reqeustHeaders.containsKey(HttpHeaderNames.CONTENT_TYPE))
                    reqeustHeaders.remove(HttpHeaderNames.CONTENT_TYPE);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //fix for  POST_TO_URI
    if (msgContext.isPropertyTrue(NhttpConstants.POST_TO_URI)) {
        path = url.toString();
    }

    if (path != null || !path.isEmpty()) {
        reqeustHeaders.put(Http2Headers.PseudoHeaderName.PATH.value().toString(), path);
    }

    if (hasEntityBody) {
        long contentLength = -1;
        String contentLengthHeader = null;
        if (reqeustHeaders.containsKey(HttpHeaderNames.CONTENT_LENGTH.toString())
                && Integer.parseInt(reqeustHeaders.get(HttpHeaderNames.CONTENT_LENGTH).toString()) > 0) {
            contentLengthHeader = reqeustHeaders.get(HttpHeaderNames.CONTENT_LENGTH).toString();
        }

        if (contentLengthHeader != null) {
            contentLength = Integer.parseInt(contentLengthHeader);
            reqeustHeaders.remove(HttpHeaderNames.CONTENT_LENGTH);
        }

        if (msgContext.getProperty(PassThroughConstants.PASSTROUGH_MESSAGE_LENGTH) != null) {
            contentLength = (Long) msgContext.getProperty(PassThroughConstants.PASSTROUGH_MESSAGE_LENGTH);
        }
        boolean forceContentLength = msgContext.isPropertyTrue(NhttpConstants.FORCE_HTTP_CONTENT_LENGTH);
        boolean forceContentLengthCopy = msgContext
                .isPropertyTrue(PassThroughConstants.COPY_CONTENT_LENGTH_FROM_INCOMING);

        if (forceContentLength) {
            if (forceContentLengthCopy && contentLength > 0) {
                reqeustHeaders.put(HttpHeaderNames.CONTENT_LENGTH.toString(), Long.toString(contentLength));
            }
        } else {
            if (contentLength != -1) {
                reqeustHeaders.put(HttpHeaderNames.CONTENT_LENGTH.toString(), Long.toString(contentLength));
            }
        }
    }

    String soapAction = msgContext.getSoapAction();
    if (soapAction == null) {
        soapAction = msgContext.getWSAAction();
        msgContext.getAxisOperation().getInputAction();
    }

    if (msgContext.isSOAP11() && soapAction != null && soapAction.length() > 0) {
        String existingHeader = reqeustHeaders.get(HTTPConstants.HEADER_SOAP_ACTION).toString();
        if (existingHeader != null) {
            reqeustHeaders.remove(existingHeader);
        }
        MessageFormatter messageFormatter = MessageFormatterDecoratorFactory
                .createMessageFormatterDecorator(msgContext);
        reqeustHeaders.put(HTTPConstants.HEADER_SOAP_ACTION.toLowerCase(),
                messageFormatter.formatSOAPAction(msgContext, null, soapAction));
        request.setHeader(HTTPConstants.USER_AGENT.toLowerCase(), "Synapse-PT-HttpComponents-NIO");
    }

    if (reqeustHeaders.containsKey(HttpHeaderNames.HOST)) {
        reqeustHeaders.remove(HttpHeaderNames.HOST);
    }
    if (reqeustHeaders.containsKey(Http2Headers.PseudoHeaderName.SCHEME.value()))
        reqeustHeaders.remove(Http2Headers.PseudoHeaderName.SCHEME.value());

    reqeustHeaders.put(Http2Headers.PseudoHeaderName.SCHEME.value().toString(),
            route.getTargetHost().getSchemeName());

    if (reqeustHeaders.containsKey(Http2Headers.PseudoHeaderName.AUTHORITY.value()))
        reqeustHeaders.remove(Http2Headers.PseudoHeaderName.AUTHORITY.value());
    reqeustHeaders.put(Http2Headers.PseudoHeaderName.AUTHORITY.value().toString(),
            route.getTargetHost().toString());
    Iterator<Map.Entry<String, String>> iterator = reqeustHeaders.entrySet().iterator();
    while (iterator.hasNext()) {
        Map.Entry<String, String> head = iterator.next();
        http2Headers.add(head.getKey(), head.getValue());
    }
    return http2Headers;
}

From source file:AdminAssetCreateTest.java

public void serverDeleteAsset() {
    mParametersSimple.put(PARAM_NAME, TEST_ASSET_NAME());
    mParametersSimple.put(PARAM_META, getPayload("/adminAssetCreateMeta.json").toString());

    setHeader(TestConfig.KEY_APPCODE, TestConfig.VALUE_APPCODE);
    setHeader(TestConfig.KEY_AUTH, TestConfig.AUTH_ADMIN_ENC);
    setHeader(HTTP.CONTENT_TYPE, MediaType.APPLICATION_FORM_URLENCODED);
    httpRequest(getURLAddress() + "/" + mParametersSimple.get(PARAM_NAME), DELETE);
    assertServer("testServerCreateSimpleAsset. Delete", Status.OK, null, false);
}