| /* |
| * Copyright (c) 2011, 2020 Oracle and/or its affiliates. All rights reserved. |
| * |
| * This program and the accompanying materials are made available under the |
| * terms of the Eclipse Public License v. 2.0 which is available at |
| * http://www.eclipse.org/legal/epl-2.0, |
| * or the Eclipse Distribution License v. 1.0 which is available at |
| * http://www.eclipse.org/org/documents/edl-v10.php. |
| * |
| * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause |
| */ |
| |
| // Contributors: |
| // gonural - Initial implementation |
| // Dmitry Kornilov - Fixes related to JPARS service versions |
| // Dmitry Kornilov - Upgrade to Jersey 2.x |
| package org.eclipse.persistence.jpars.test.util; |
| |
| import jakarta.ws.rs.client.Client; |
| import org.eclipse.persistence.jpa.rs.MatrixParameters; |
| import org.eclipse.persistence.jpa.rs.PersistenceContext; |
| import org.eclipse.persistence.jpa.rs.QueryParameters; |
| import org.eclipse.persistence.jpa.rs.exceptions.ErrorResponse; |
| import org.eclipse.persistence.jpa.rs.features.ServiceVersion; |
| import org.eclipse.persistence.jpa.rs.util.list.ReadAllQueryResultCollection; |
| import org.eclipse.persistence.jpa.rs.util.list.SimpleHomogeneousList; |
| import org.eclipse.persistence.jpars.test.server.RestCallFailedException; |
| |
| import javax.imageio.ImageIO; |
| import jakarta.ws.rs.client.ClientBuilder; |
| import jakarta.ws.rs.client.Entity; |
| import jakarta.ws.rs.core.MediaType; |
| import jakarta.ws.rs.core.Response; |
| import jakarta.xml.bind.JAXBException; |
| import java.awt.image.BufferedImage; |
| import java.io.BufferedWriter; |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.File; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.UnsupportedEncodingException; |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.logging.Logger; |
| |
| import static org.junit.Assert.fail; |
| |
| /** |
| * Helper class with static utility methods used for REST service testing. |
| * |
| * @author gonural - initial implementation |
| * Dmitry Kornilov - JAXRS 2.x, Jersey 2.x |
| */ |
| public class RestUtils { |
| public static final String JPA_RS_VERSION_STRING = "jpars.version.string"; |
| |
| private static final String APPLICATION_LOCATION = "/eclipselink.jpars.test/persistence/"; |
| private static final String SERVER_URI_BASE = "server.uri.base"; |
| private static final String DEFAULT_SERVER_URI_BASE = "http://localhost:8080"; |
| private static final String JSON_REST_MESSAGE_FOLDER = "org/eclipse/persistence/jpars/test/restmessage/json/"; |
| private static final String XML_REST_MESSAGE_FOLDER = "org/eclipse/persistence/jpars/test/restmessage/xml/"; |
| private static final String IMAGE_FOLDER = "org/eclipse/persistence/jpars/test/image/"; |
| |
| private static final Logger logger = Logger.getLogger("org.eclipse.persistence.jpars.test.server"); |
| private static final Client client = ClientBuilder.newClient(); |
| |
| /** |
| * Gets the server uri. |
| * |
| * @return the server uri |
| * @throws URISyntaxException the URI syntax exception |
| */ |
| public static URI getServerURI() throws URISyntaxException { |
| String serverURIBase = System.getProperty(SERVER_URI_BASE, DEFAULT_SERVER_URI_BASE); |
| return new URI(serverURIBase + APPLICATION_LOCATION); |
| } |
| |
| /** |
| * Gets the server uri. |
| * |
| * @return the server uri |
| */ |
| public static URI getServerURI(String versionString) throws URISyntaxException { |
| String serverURIBase = System.getProperty(SERVER_URI_BASE, DEFAULT_SERVER_URI_BASE); |
| String versionStringUrlFragment = versionString == null || versionString.equals("") ? "" : versionString + "/"; |
| return new URI(serverURIBase + APPLICATION_LOCATION + versionStringUrlFragment); |
| } |
| |
| /** |
| * Marshals given object. |
| * |
| * @param context persistence context |
| * @param object object to marshal |
| * @param mediaType media type to use (XML or JSON) |
| * @return string containing XML or JSON representation of given object |
| */ |
| public static String marshal(PersistenceContext context, Object object, MediaType mediaType) |
| throws JAXBException, UnsupportedEncodingException { |
| return marshal(context, object, mediaType, true); |
| } |
| |
| /** |
| * Marshals given object. |
| * |
| * @param context persistence context |
| * @param object object to marshal |
| * @param mediaType media type to use (XML or JSON) |
| * @param sendRelationships if this is set to true, relationships will be sent as links instead of sending |
| * the actual objects in the relationships |
| * @return string containing XML or JSON representation of given object |
| */ |
| public static String marshal(PersistenceContext context, Object object, MediaType mediaType, boolean sendRelationships) |
| throws JAXBException, UnsupportedEncodingException { |
| ByteArrayOutputStream os = new ByteArrayOutputStream(); |
| context.marshall(object, mediaType, os, sendRelationships); |
| return os.toString("UTF-8"); |
| } |
| |
| /** |
| * Unmarshals given string to an object of given type. |
| * |
| * @param context persistence context |
| * @param msg string to unmarshal |
| * @param resultClass resulting object type |
| * @param mediaType media type to use (XML or JSON) |
| * @return unmarshaled object |
| */ |
| @SuppressWarnings("unchecked") |
| public static <T> T unmarshal(PersistenceContext context, String msg, Class<T> resultClass, MediaType mediaType) throws JAXBException { |
| return (T) context.unmarshalEntity(resultClass.getSimpleName(), mediaType, new ByteArrayInputStream(msg.getBytes())); |
| } |
| |
| /** |
| * Reads object of given type with given ID. |
| * |
| * @param context persistence context |
| * @param id id of the obejct to retrieve |
| * @param resultClass object type |
| * @param outputMediaType media type to use (XML or JSON) |
| * @param tenantId tenantId or null if no tenant |
| * @return retrieved object |
| */ |
| public static <T> T restReadObject(PersistenceContext context, |
| Object id, |
| Class<T> resultClass, |
| MediaType outputMediaType, |
| Map<String, String> tenantId) |
| throws RestCallFailedException, URISyntaxException, JAXBException { |
| final String result = restRead(context, id, resultClass, outputMediaType, tenantId); |
| return unmarshal(context, result, resultClass, outputMediaType); |
| } |
| |
| /** |
| * Reads object of given type with given ID. |
| * |
| * @param context persistent context |
| * @param id id of the object to retrieve |
| * @param resultClass object type |
| * @param outputMediaType media type to use (XML or JSON) |
| * @return retrieved object |
| */ |
| public static <T> T restReadObject(PersistenceContext context, |
| Object id, |
| Class<T> resultClass, |
| MediaType outputMediaType) |
| throws RestCallFailedException, URISyntaxException, JAXBException { |
| return restReadObject(context, id, resultClass, outputMediaType, null); |
| } |
| |
| /** |
| * Reads object of given type with given ID. |
| * |
| * @param context persistent context |
| * @param id id of the object to retrieve |
| * @param resultClass object type |
| * @return retrieved object |
| */ |
| public static <T> T restReadObject(PersistenceContext context, |
| Object id, |
| Class<T> resultClass) throws RestCallFailedException, URISyntaxException, JAXBException { |
| return restReadObject(context, id, resultClass, MediaType.APPLICATION_JSON_TYPE); |
| } |
| |
| /** |
| * Retrieves and returns a string representation (not unmarshalled) of an object with given id and type. |
| * |
| * @param context persistence context |
| * @param id id of the object to retrieve |
| * @param resultClass type of the object to retrieve |
| * @param outputMediaType media type to use (XML or JSON) |
| * @param tenantId tenantId or null if no tenant |
| * @return XML or JSON representation of retrieved object |
| */ |
| public static String restRead(PersistenceContext context, |
| Object id, |
| Class resultClass, |
| MediaType outputMediaType, |
| Map<String, String> tenantId) throws RestCallFailedException, URISyntaxException { |
| final String uri = new UriBuilder(context).addTenantInfo(tenantId).addEntity(resultClass.getSimpleName(), id).toString(); |
| final Response response = doGet(context, uri, outputMediaType); |
| return response.readEntity(String.class); |
| } |
| |
| /** |
| * Retrieves and returns a string representation (not unmarshalled) of an object with given id and type. |
| * |
| * @param context persistence context |
| * @param id id of the object to retrieve |
| * @param resultClass type of the object to retrieve |
| * @param outputMediaType media type to use (XML or JSON) |
| * @return XML or JSON representation of retrieved object |
| */ |
| public static String restRead(PersistenceContext context, Object id, Class resultClass, MediaType outputMediaType) |
| throws RestCallFailedException, URISyntaxException { |
| return restRead(context, id, resultClass, outputMediaType, null); |
| } |
| |
| /** |
| * Retrieves and returns a string representation (not unmarshalled) of an object with given id and type. |
| * |
| * @param context persistence context |
| * @param id id of the object to retrieve |
| * @param resultClass type of the object to retrieve |
| * @return XML or JSON representation of retrieved object |
| */ |
| public static String restRead(PersistenceContext context, Object id, Class resultClass) |
| throws RestCallFailedException, URISyntaxException { |
| return restRead(context, id, resultClass, MediaType.APPLICATION_JSON_TYPE); |
| } |
| |
| /** |
| * Retrieved object referenced by given link. |
| * |
| * @param context persistence context |
| * @param href link to object to retrieve |
| * @param resultClass type of the object to retrieve |
| * @return retrieved object |
| */ |
| @SuppressWarnings("unchecked") |
| public static <T> T restReadByHref(PersistenceContext context, String href, Class<T> resultClass) |
| throws RestCallFailedException, JAXBException { |
| final Response response = doGet(context, href, MediaType.APPLICATION_JSON_TYPE); |
| final String result = response.readEntity(String.class); |
| return unmarshal(context, result, resultClass, MediaType.APPLICATION_JSON_TYPE); |
| } |
| |
| /** |
| * REST GET entity with hints. |
| * |
| * @param context persistent context |
| * @param id entity ID |
| * @param type entity type |
| * @param hints hints list |
| * @param outputMediaType media type to use (XML or JSON) |
| * @return response in string |
| */ |
| public static String restReadWithHints(PersistenceContext context, |
| Object id, |
| String type, |
| Map<String, String> hints, |
| MediaType outputMediaType) throws RestCallFailedException, URISyntaxException { |
| final String uri = new UriBuilder(context).addEntity(type, id).addHints(hints).toString(); |
| final Response response = doGet(context, uri, outputMediaType); |
| return response.readEntity(String.class); |
| } |
| |
| /** |
| * Updates given object. |
| * |
| * @param <T> the generic type |
| * @param context persistence context |
| * @param object object to update |
| * @param resultClass the result class |
| * @param tenantId the tenant id |
| * @param mediaType media type to use (XML or JSON) |
| * @param sendLinks if true links will be marshalled |
| * @return updated object |
| */ |
| @SuppressWarnings("unchecked") |
| public static <T> T restUpdate(PersistenceContext context, |
| Object object, |
| Class<T> resultClass, |
| Map<String, String> tenantId, |
| MediaType mediaType, |
| boolean sendLinks) |
| throws RestCallFailedException, URISyntaxException, JAXBException, UnsupportedEncodingException { |
| String marshalledObj = marshal(context, object, mediaType, sendLinks); |
| String uri = new UriBuilder(context).addTenantInfo(tenantId).addEntity(resultClass.getSimpleName()).toString(); |
| Response response = doPost(context, uri, Entity.entity(marshalledObj, mediaType), mediaType); |
| return unmarshal(context, response.readEntity(String.class), resultClass, mediaType); |
| } |
| |
| /** |
| * Updates given object. |
| * |
| * @param context persistence context |
| * @param object object to update |
| * @param resultClass the result class |
| * @return updated object |
| */ |
| public static <T> T restUpdate(PersistenceContext context, Object object, Class<T> resultClass) |
| throws RestCallFailedException, URISyntaxException, JAXBException, UnsupportedEncodingException { |
| return restUpdate(context, object, resultClass, null, MediaType.APPLICATION_JSON_TYPE, true); |
| } |
| |
| /** |
| * Updates given object. |
| * |
| * @param context persistence context |
| * @param object object to update |
| * @param resultClass the result class |
| * @param sendLinks if true links will be marshalled |
| * @return updated object |
| */ |
| public static <T> T restUpdate(PersistenceContext context, Object object, Class<T> resultClass, boolean sendLinks) |
| throws RestCallFailedException, URISyntaxException, JAXBException, UnsupportedEncodingException { |
| return restUpdate(context, object, resultClass, null, MediaType.APPLICATION_JSON_TYPE, sendLinks); |
| } |
| |
| /** |
| * Posts a given message to update an object. Returns XML or JSON representation of updated object. |
| * |
| * @param context persistence context |
| * @param message XML or JSON representation of an object to update |
| * @param resultClass the result object type |
| * @param tenantId the tenant id |
| * @param mediaType media type to use (XML or JSON) |
| * @return updated object in XMK or JSON depending on passed media type |
| */ |
| public static String restUpdateStr(PersistenceContext context, |
| String message, |
| Class resultClass, |
| Map<String, String> tenantId, |
| MediaType mediaType) throws RestCallFailedException, URISyntaxException { |
| final String uri = new UriBuilder(context).addTenantInfo(tenantId).addEntity(resultClass.getSimpleName()).toString(); |
| final Response response = doPost(context, uri, Entity.entity(message, mediaType), mediaType); |
| return response.readEntity(String.class); |
| } |
| |
| /** |
| * Rest create. |
| * |
| * @param context persistence context |
| * @param object the object to create |
| * @param resultClass the result object type |
| * @param tenantId the tenant id |
| * @param mediaType media type to use (XML or JSON) |
| * @param sendLinks if this is set to true, relationships will be sent as links instead of sending |
| * the actual objects in the relationships |
| * @return created object |
| */ |
| @SuppressWarnings("unchecked") |
| public static <T> T restCreate(PersistenceContext context, |
| Object object, |
| Class<T> resultClass, |
| Map<String, String> tenantId, |
| MediaType mediaType, boolean sendLinks) |
| throws RestCallFailedException, URISyntaxException, JAXBException, UnsupportedEncodingException { |
| final String marshalledObj = marshal(context, object, mediaType, sendLinks); |
| final String uri = new UriBuilder(context).addTenantInfo(tenantId).addEntity(resultClass.getSimpleName()).toString(); |
| final Response response = doPut(context, uri, Entity.entity(marshalledObj, mediaType), mediaType); |
| return unmarshal(context, response.readEntity(String.class), resultClass, mediaType); |
| } |
| |
| /** |
| * Creates an object. |
| * |
| * @param context persistence context |
| * @param object the object to create |
| * @param resultClass the result object type |
| * @param mediaType media type to use (XML or JSON) |
| * @return created object |
| */ |
| public static <T> T restCreate(PersistenceContext context, |
| Object object, |
| Class<T> resultClass, |
| MediaType mediaType) |
| throws RestCallFailedException, URISyntaxException, JAXBException, UnsupportedEncodingException { |
| return restCreate(context, object, resultClass, null, mediaType, false); |
| } |
| |
| /** |
| * Creates an object. |
| * |
| * @param context persistence context |
| * @param object the object to create |
| * @param resultClass the result object type |
| * @return created object |
| */ |
| public static <T> T restCreate(PersistenceContext context, Object object, Class<T> resultClass) |
| throws RestCallFailedException, URISyntaxException, JAXBException, UnsupportedEncodingException { |
| return restCreate(context, object, resultClass, MediaType.APPLICATION_JSON_TYPE); |
| } |
| |
| /** |
| * Rest create an object from string message. |
| * |
| * @param context persistence context |
| * @param msg XML or JSON object representation |
| * @param resultClass the result object type |
| * @param mediaType media type to use (XML or JSON) |
| * @return created object |
| */ |
| @SuppressWarnings("unchecked") |
| public static <T> T restCreateStr(PersistenceContext context, |
| String msg, |
| Class<T> resultClass, |
| MediaType mediaType) throws URISyntaxException, JAXBException { |
| final String uri = new UriBuilder(context).addEntity(resultClass.getSimpleName()).toString(); |
| final Response response = doPut(context, uri, Entity.entity(msg, mediaType), mediaType); |
| return unmarshal(context, response.readEntity(String.class), resultClass, mediaType); |
| } |
| |
| /** |
| * Rest create with sequence. |
| * |
| * @param context persistence context |
| * @param msg XML or JSON object representation |
| * @param resultClass the result object type |
| * @param mediaType media type to use (XML or JSON) |
| */ |
| public static void restCreateWithSequence(PersistenceContext context, |
| String msg, |
| Class resultClass, |
| MediaType mediaType) throws URISyntaxException { |
| final String uri = new UriBuilder(context).addEntity(resultClass.getSimpleName()).toString(); |
| doPut(context, uri, Entity.entity(msg, mediaType), mediaType); |
| } |
| |
| /** |
| * Rest delete. |
| * |
| * @param context persistence context |
| * @param id ID of object to delete |
| * @param resultClass the result object type |
| * @param tenantId the tenant id |
| * @param mediaType media type to use (XML or JSON) |
| */ |
| public static void restDelete(PersistenceContext context, |
| Object id, |
| Class resultClass, |
| Map<String, String> tenantId, |
| MediaType mediaType) throws RestCallFailedException, URISyntaxException { |
| final String uri = new UriBuilder(context).addTenantInfo(tenantId).addEntity(resultClass.getSimpleName(), id).toString(); |
| doDelete(context, uri, mediaType); |
| } |
| |
| /** |
| * Rest delete. |
| * |
| * @param context persistence context |
| * @param id ID of object to delete |
| * @param resultClass the result object type |
| * @param mediaType media type to use (XML or JSON) |
| */ |
| public static void restDelete(PersistenceContext context, |
| Object id, |
| Class resultClass, |
| MediaType mediaType) throws RestCallFailedException, URISyntaxException { |
| restDelete(context, id, resultClass, null, mediaType); |
| } |
| |
| /** |
| * Rest delete. |
| * |
| * @param context persistence context |
| * @param id ID of object to delete |
| * @param resultClass the result object type |
| */ |
| public static void restDelete(PersistenceContext context, Object id, Class resultClass) |
| throws RestCallFailedException, URISyntaxException { |
| restDelete(context, id, resultClass, null, MediaType.APPLICATION_JSON_TYPE); |
| } |
| |
| /** |
| * Rest named multi result query. |
| * |
| * @param context persistence context |
| * @param queryName the query name |
| * @param parameters the parameters |
| * @param hints the hints |
| * @param mediaType media type to use (XML or JSON) |
| * @return query result in string |
| */ |
| public static String restNamedMultiResultQueryResult(PersistenceContext context, |
| String queryName, |
| Map<String, Object> parameters, |
| Map<String, String> hints, |
| MediaType mediaType) throws URISyntaxException { |
| final String uri = new UriBuilder(context).addQuery(queryName).addParameters(parameters).addHints(hints).toString(); |
| final Response response = doGet(context, uri, mediaType); |
| return response.readEntity(String.class); |
| } |
| |
| /** |
| * Rest named multi result query. |
| * |
| * @param context persistence context |
| * @param queryName the query name |
| * @param returnType the result object type |
| * @param parameters the parameters |
| * @param hints the hints |
| * @param mediaType media type to use (XML or JSON) |
| * @return list of objects |
| */ |
| @SuppressWarnings("unchecked") |
| public static <T> List<T> restNamedMultiResultQuery(PersistenceContext context, |
| String queryName, |
| Class<T> returnType, |
| Map<String, Object> parameters, |
| Map<String, String> hints, |
| MediaType mediaType) throws URISyntaxException, JAXBException { |
| final String result = restNamedMultiResultQueryResult(context, queryName, parameters, hints, mediaType); |
| |
| if (context.getServiceVersion().compareTo(ServiceVersion.VERSION_2_0) >= 0) { |
| // 2.0 or higher |
| final Object obj = context.unmarshalEntity("ReadAllQueryResultCollection", mediaType, new ByteArrayInputStream(result.getBytes())); |
| if (obj instanceof ReadAllQueryResultCollection) { |
| final ReadAllQueryResultCollection c = (ReadAllQueryResultCollection) obj; |
| return (List<T>)c.getItems(); |
| } else { |
| return Collections.emptyList(); |
| } |
| } else { |
| // 1.0 or no version |
| final Object obj = context.unmarshalEntity(returnType.getSimpleName(), mediaType, new ByteArrayInputStream(result.getBytes())); |
| if (obj instanceof SimpleHomogeneousList) { |
| return Collections.emptyList(); |
| } else { |
| return (List<T>)obj; |
| } |
| } |
| } |
| |
| /** |
| * Rest named multi result query. |
| * |
| * @param context persistence context |
| * @param queryName the query name |
| * @param returnType the result object type |
| * @param parameters the parameters |
| * @param hints the hints |
| * @return list of objects |
| */ |
| public static <T> List<T> restNamedMultiResultQuery(PersistenceContext context, |
| String queryName, |
| Class<T> returnType, |
| Map<String, Object> parameters, |
| Map<String, String> hints) throws URISyntaxException, JAXBException { |
| return restNamedMultiResultQuery(context, queryName, returnType, parameters, hints, MediaType.APPLICATION_JSON_TYPE); |
| } |
| |
| /** |
| * Rest named single result query. |
| * |
| * @param context persistence context |
| * @param queryName the query name |
| * @param parameters the parameters |
| * @param hints the hints |
| * @param mediaType media type to use (XML or JSON) |
| * @return query result in string |
| */ |
| public static String restNamedSingleResultQueryResult(PersistenceContext context, |
| String queryName, |
| Map<String, Object> parameters, |
| Map<String, String> hints, |
| MediaType mediaType) throws URISyntaxException { |
| final String uri = new UriBuilder(context).addSingleResultQuery(queryName).addParameters(parameters).addHints(hints).toString(); |
| final Response response = doGet(context, uri, mediaType); |
| return response.readEntity(String.class); |
| } |
| |
| /** |
| * Rest named single result query. |
| * |
| * @param context persistence context |
| * @param queryName the query name |
| * @param returnType the result object type |
| * @param parameters the parameters |
| * @param hints the hints |
| * @param mediaType media type to use (XML or JSON) |
| * @return object |
| */ |
| public static Object restNamedSingleResultQuery(PersistenceContext context, |
| String queryName, |
| String returnType, |
| Map<String, Object> parameters, |
| Map<String, String> hints, |
| MediaType mediaType) throws URISyntaxException, JAXBException { |
| final String result = restNamedSingleResultQueryResult(context, queryName, parameters, hints, mediaType); |
| return context.unmarshalEntity(returnType, mediaType, new ByteArrayInputStream(result.getBytes())); |
| } |
| |
| /** |
| * Rest named single result query. |
| * |
| * @param context persistence context |
| * @param queryName the query name |
| * @param returnType the result object type |
| * @param parameters the parameters |
| * @param hints the hints |
| * @return object |
| */ |
| public static Object restNamedSingleResultQuery(PersistenceContext context, |
| String queryName, |
| String returnType, |
| Map<String, Object> parameters, |
| Map<String, String> hints) throws URISyntaxException, JAXBException { |
| return restNamedSingleResultQuery(context, queryName, returnType, parameters, hints, MediaType.APPLICATION_JSON_TYPE); |
| } |
| |
| /** |
| * Rest named single result query in byte array. |
| * |
| * @param context the persistent context |
| * @param queryName the query name |
| * @param parameters the parameters |
| * @param hints the hints |
| * @param outputMediaType the output media type |
| * @return the byte[] |
| * @throws URISyntaxException the URI syntax exception |
| */ |
| public static byte[] restNamedSingleResultQueryInByteArray(PersistenceContext context, |
| String queryName, |
| Map<String, Object> parameters, |
| Map<String, String> hints, |
| MediaType outputMediaType) throws URISyntaxException { |
| final String uri = new UriBuilder(context).addSingleResultQuery(queryName).addParameters(parameters).addHints(hints).toString(); |
| final Response response = doGet(context, uri, outputMediaType); |
| |
| ByteArrayOutputStream baos = null; |
| if (outputMediaType == MediaType.APPLICATION_OCTET_STREAM_TYPE) { |
| try { |
| //BufferedImage image = ImageIO.read(response.getEntityInputStream()); |
| BufferedImage image = ImageIO.read(response.readEntity(InputStream.class)); |
| baos = new ByteArrayOutputStream(); |
| ImageIO.write(image, "png", baos); |
| return baos.toByteArray(); |
| } catch (IOException e) { |
| e.printStackTrace(); |
| } finally { |
| if (baos != null) { |
| try { |
| baos.close(); |
| } catch (IOException e) { |
| e.printStackTrace(); |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Rest update relationship. |
| * |
| * @param context persistence context |
| * @param objectId the object id |
| * @param relationshipName the relationship name |
| * @param newValue the new value |
| * @param mediaType media type to use (XML or JSON) |
| * @return updated object |
| */ |
| @SuppressWarnings("unchecked") |
| public static <T> T restUpdateRelationship(PersistenceContext context, |
| String objectId, |
| String relationshipName, |
| Object newValue, |
| Class<T> resultClass, |
| MediaType mediaType) |
| throws RestCallFailedException, URISyntaxException, JAXBException, UnsupportedEncodingException { |
| final String newValueStr = marshal(context, newValue, mediaType); |
| final String uri = new UriBuilder(context).addEntity(resultClass.getSimpleName(), objectId, relationshipName).toString(); |
| final Response response = doPost(context, uri, Entity.entity(newValueStr, mediaType), mediaType); |
| return unmarshal(context, response.readEntity(String.class), resultClass, mediaType); |
| } |
| |
| /** |
| * Rest update bidirectional relationship. |
| * |
| * @param context persistence context |
| * @param objectId the object id |
| * @param objectType the object type |
| * @param relationshipName the relationship name |
| * @param newValue the new value |
| * @param mediaType the media type |
| * @param partner the partner |
| * @param sendLinks if this is set to true, relationships will be sent as links instead of sending |
| * the actual objects in the relationships |
| * @return the string |
| */ |
| public static String restUpdateBidirectionalRelationship(PersistenceContext context, |
| String objectId, |
| Class objectType, |
| String relationshipName, |
| Object newValue, |
| MediaType mediaType, |
| String partner, |
| boolean sendLinks) |
| throws RestCallFailedException, URISyntaxException, JAXBException, UnsupportedEncodingException { |
| // Construct parameters |
| final Map<String, Object> params = new HashMap<>(1); |
| if (partner != null) { |
| params.put(MatrixParameters.JPARS_RELATIONSHIP_PARTNER, partner); |
| } |
| |
| final String newValueStr = marshal(context, newValue, mediaType, sendLinks); |
| final String uri = new UriBuilder(context).addEntity(objectType.getSimpleName(), objectId, relationshipName).addParameters(params).toString(); |
| final Response response = doPost(context, uri, Entity.entity(newValueStr, mediaType), mediaType); |
| return response.readEntity(String.class); |
| } |
| |
| /** |
| * Rest remove bidirectional relationship. |
| * |
| * @param context persistence context |
| * @param objectId the object id |
| * @param objectType the object type |
| * @param relationshipName the relationship name |
| * @param mediaType the media type |
| * @param partner the partner |
| * @param listItemId the list item id |
| * @return the string |
| */ |
| public static String restRemoveBidirectionalRelationship(PersistenceContext context, |
| String objectId, |
| Class objectType, |
| String relationshipName, |
| MediaType mediaType, |
| String partner, |
| String listItemId) |
| throws RestCallFailedException, URISyntaxException, JAXBException { |
| // Construct hints |
| final Map<String, String> hints = new HashMap<>(); |
| if (partner != null) { |
| hints.put(QueryParameters.JPARS_RELATIONSHIP_PARTNER, partner); |
| } |
| if (listItemId != null) { |
| hints.put(QueryParameters.JPARS_LIST_ITEM_ID, listItemId); |
| } |
| |
| final String uri = new UriBuilder(context).addEntity(objectType.getSimpleName(), objectId, relationshipName).addHints(hints).toString(); |
| final Response response = doDelete(context, uri, mediaType); |
| return response.readEntity(String.class); |
| } |
| |
| /** |
| * Gets the JSON message. |
| * |
| * @param inputFile the input file |
| * @return the JSON message |
| */ |
| public static String getJSONMessage(String inputFile) { |
| InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(JSON_REST_MESSAGE_FOLDER + inputFile); |
| return convertStreamToString(is); |
| } |
| |
| /** |
| * Gets the XML message. |
| * |
| * @param inputFile the input file |
| * @return the XML message |
| */ |
| public static String getXMLMessage(String inputFile) { |
| InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(XML_REST_MESSAGE_FOLDER + inputFile); |
| return convertStreamToString(is); |
| } |
| |
| /** |
| * Convert image to byte array. |
| * |
| * @param imageName the image name |
| * @return the byte[] |
| * @throws IOException Signals that an I/O exception has occurred. |
| */ |
| public static byte[] convertImageToByteArray(String imageName) throws IOException { |
| final InputStream is = Thread.currentThread().getContextClassLoader().getResourceAsStream(IMAGE_FOLDER + imageName); |
| final BufferedImage originalImage = ImageIO.read(is); |
| final ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| ImageIO.write(originalImage, getExtension(new File(imageName)), baos); |
| return baos.toByteArray(); |
| } |
| |
| /** |
| * Rest find attribute. |
| * |
| * @param context the context |
| * @param id the id |
| * @param objectType the object type |
| * @param attribute the attribute |
| * @param outputMediaType the output media type |
| * @return attribute |
| */ |
| public static String restFindAttribute(PersistenceContext context, |
| Object id, |
| Class objectType, |
| String attribute, |
| MediaType outputMediaType) throws RestCallFailedException, URISyntaxException { |
| final String uri = new UriBuilder(context).addEntity(objectType.getSimpleName(), id, attribute).toString(); |
| final Response response = doGet(context, uri, outputMediaType); |
| return response.readEntity(String.class); |
| } |
| |
| /** |
| * Rest find attribute query. |
| * |
| * @param context the context |
| * @param id the id |
| * @param objectType the object type |
| * @param attribute the attribute |
| * @param parameters the parameters |
| * @param hints the hints |
| * @param outputMediaType the output media type |
| * @return attribute |
| */ |
| public static String restFindAttribute(PersistenceContext context, |
| Object id, |
| Class objectType, |
| String attribute, |
| Map<String, Object> parameters, |
| Map<String, String> hints, |
| MediaType outputMediaType) throws RestCallFailedException, URISyntaxException { |
| final String uri = new UriBuilder(context).addEntity(objectType.getSimpleName(), id, attribute).addParameters(parameters).addHints(hints).toString(); |
| final Response response = doGet(context, uri, outputMediaType); |
| return response.readEntity(String.class); |
| } |
| |
| /** |
| * Rest update query. |
| * |
| * @param context the context |
| * @param queryName the query name |
| * @param parameters the parameters |
| * @param hints the hints |
| * @param mediaType the media type |
| * @return the string |
| */ |
| public static String restUpdateQuery(PersistenceContext context, |
| String queryName, |
| Map<String, Object> parameters, |
| Map<String, String> hints, |
| MediaType mediaType) throws URISyntaxException { |
| final String uri = new UriBuilder(context).addQuery(queryName).addParameters(parameters).addHints(hints).toString(); |
| final Response response = doPost(context, uri, Entity.entity(null, mediaType), mediaType); |
| return response.readEntity(String.class); |
| } |
| |
| /** |
| * Executes GET request to the server. |
| * |
| * @param context persistence context |
| * @param uri uri |
| * @param outputMediaType media type to use |
| * @return response |
| */ |
| public static Response doGet(PersistenceContext context, String uri, MediaType outputMediaType) { |
| final Response response = client.target(uri).request(outputMediaType).get(); |
| checkResponse(Response.Status.OK, context, outputMediaType, response); |
| return response; |
| } |
| |
| /** |
| * Executes POST request to the server. |
| * |
| * @param context persistence context |
| * @param uri uri |
| * @param entity entity to post |
| * @param outputMediaType media type to use |
| * @return response |
| */ |
| public static Response doPost(PersistenceContext context, String uri, Entity entity, MediaType outputMediaType) { |
| final Response response = client.target(uri).request(outputMediaType).accept(outputMediaType).post(entity); |
| checkResponse(Response.Status.OK, context, outputMediaType, response); |
| return response; |
| } |
| |
| /** |
| * Executes PUT request to the server. |
| * |
| * @param context persistence context |
| * @param uri uri |
| * @param entity entity to create |
| * @param outputMediaType media type to use |
| * @return response |
| */ |
| public static Response doPut(PersistenceContext context, String uri, Entity entity, MediaType outputMediaType) { |
| final Response response = client.target(uri).request(outputMediaType).put(entity); |
| checkResponse(Response.Status.CREATED, context, outputMediaType, response); |
| return response; |
| } |
| |
| /** |
| * Executes DELETE request to the server. |
| * |
| * @param context persistence context |
| * @param uri uri |
| * @param outputMediaType media type to use |
| * @return response |
| */ |
| public static Response doDelete(PersistenceContext context, String uri, MediaType outputMediaType) { |
| final Response response = client.target(uri).request(outputMediaType).delete(); |
| checkResponse(Response.Status.OK, context, outputMediaType, response); |
| return response; |
| } |
| |
| private static String getExtension(File f) { |
| String ext = null; |
| String s = f.getName(); |
| int i = s.lastIndexOf('.'); |
| |
| if (i > 0 && i < s.length() - 1) { |
| ext = s.substring(i + 1).toLowerCase(); |
| } |
| return ext; |
| } |
| |
| @SuppressWarnings("unused") |
| private static void writeToFile(String data) { |
| BufferedWriter writer = null; |
| try { |
| String fileName = (System.currentTimeMillis() + ".txt"); |
| writer = new BufferedWriter(new FileWriter(fileName)); |
| writer.write(data); |
| } catch (Exception e) { |
| e.printStackTrace(); |
| } finally { |
| if (writer != null) { |
| try { |
| writer.close(); |
| } catch (IOException e) { |
| e.printStackTrace(); |
| } |
| } |
| } |
| } |
| |
| private static String convertStreamToString(InputStream is) { |
| try { |
| return new java.util.Scanner(is).useDelimiter("\\A").next(); |
| } catch (Exception e) { |
| return null; |
| } |
| } |
| |
| private static void checkResponse(Response.Status status, PersistenceContext context, MediaType outputMediaType, Response response) { |
| if (response.getStatus() != status.getStatusCode()) { |
| restCallFailed(context, response, outputMediaType); |
| } |
| } |
| |
| private static void restCallFailed(PersistenceContext context, Response response, MediaType mediaType) { |
| final String entity = response.readEntity(String.class); |
| if ((entity != null) && (!entity.isEmpty())) { |
| if ((entity.contains("problemType")) && (entity.contains("title") && (entity.contains("httpStatus")))) { |
| try { |
| ErrorResponse errorDetail = (ErrorResponse) context.unmarshalEntity(ErrorResponse.class.getSimpleName(), mediaType, new ByteArrayInputStream(entity.getBytes())); |
| throw new RestCallFailedException(response.getStatus(), errorDetail); |
| } catch (JAXBException e) { |
| fail("Exception thrown unmarshalling: " + e); |
| } |
| } |
| } |
| throw new RestCallFailedException(response.getStatus()); |
| } |
| } |