public Value convertValue(Object object) { if (object instanceof Value) { return (Value) object; } ValueFactory valueFactory = SimpleValueFactory.getInstance(); if (object instanceof String) { return valueFactory.createLiteral((String) object); } if (object instanceof Integer) { return valueFactory.createLiteral((Integer) object); } if (object instanceof Double) { return valueFactory.createLiteral((Double) object); } throw new NotSupportedException("Value is not supported: " + object.getClass()); }
@Override public Response toResponse(Exception e) { WrapperResponseEntity response = null; if (e instanceof NotFoundException) { response = new WrapperResponseEntity(ResponseCode.NOT_FOUND); } else if (e instanceof NotAllowedException) { response = new WrapperResponseEntity(ResponseCode.FORBIDDEN); } else if (e instanceof JsonProcessingException) { response = new WrapperResponseEntity(ResponseCode.ERROR_JSON); } else if (e instanceof NotSupportedException) { response = new WrapperResponseEntity(ResponseCode.UNSUPPORTED_MEDIA_TYPE); } else { response = excetionWrapper != null ? excetionWrapper.toResponse(e) : null; if (response == null) response = new WrapperResponseEntity(ResponseCode.INTERNAL_SERVER_ERROR); } return Response.status(response.httpStatus()).type(MediaType.APPLICATION_JSON) .entity(response).build(); }
@Override public Response toResponse(Exception e) { WrapperResponseEntity response = null; if (e instanceof NotFoundException) { response = new WrapperResponseEntity(ResponseCode.NOT_FOUND); } else if (e instanceof NotAllowedException) { response = new WrapperResponseEntity(ResponseCode.FORBIDDEN); } else if (e instanceof JsonProcessingException) { response = new WrapperResponseEntity(ResponseCode.ERROR_JSON); } else if (e instanceof NotSupportedException) { response = new WrapperResponseEntity(ResponseCode.UNSUPPORTED_MEDIA_TYPE); } else { response = excetionWrapper != null ? excetionWrapper.toResponse(e) : null; if(response == null)response = new WrapperResponseEntity(ResponseCode.INTERNAL_SERVER_ERROR); } return Response.status(response.httpStatus()).type(MediaType.APPLICATION_JSON).entity(response).build(); }
@Test public void testCreateException() { assertExceptionType(Response.Status.INTERNAL_SERVER_ERROR, InternalServerErrorException.class); assertExceptionType(Response.Status.NOT_FOUND, NotFoundException.class); assertExceptionType(Response.Status.FORBIDDEN, ForbiddenException.class); assertExceptionType(Response.Status.BAD_REQUEST, BadRequestException.class); assertExceptionType(Response.Status.METHOD_NOT_ALLOWED, NotAllowedException.class); assertExceptionType(Response.Status.UNAUTHORIZED, NotAuthorizedException.class); assertExceptionType(Response.Status.NOT_ACCEPTABLE, NotAcceptableException.class); assertExceptionType(Response.Status.UNSUPPORTED_MEDIA_TYPE, NotSupportedException.class); assertExceptionType(Response.Status.SERVICE_UNAVAILABLE, ServiceUnavailableException.class); assertExceptionType(Response.Status.TEMPORARY_REDIRECT, RedirectionException.class); assertExceptionType(Response.Status.LENGTH_REQUIRED, ClientErrorException.class); assertExceptionType(Response.Status.BAD_GATEWAY, ServerErrorException.class); assertExceptionType(Response.Status.NO_CONTENT, WebApplicationException.class); }
public void loginDialog(String message) { try { if (!getTrpSets().isServerSideActivated()) { throw new NotSupportedException("Connecting to the server not supported yet!"); } // detachListener(); if (loginDialog != null && !loginDialog.isDisposed()) { loginDialog.close(); } List<String> storedUsers = TrpGuiPrefs.getUsers(); loginDialog = new TrpLoginDialog(getShell(), this, message, storedUsers.toArray(new String[0]), TrpServerConn.SERVER_URIS, TrpServerConn.DEFAULT_URI_INDEX); loginDialog.open(); // attachListener(); } catch (Throwable e) { onError("Error during login", "Unable to login to server", e); ui.updateLoginInfo(false, "", ""); } }
@Override @SuppressWarnings("unchecked") public void writeTo(PMessage entity, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException { try { provider.getSerializer(mediaType.toString()) .serialize(entityStream, entity); } catch (NotSupportedException e) { throw new ProcessingException("Unknown media type: " + mediaType, e); } catch (SerializerException se) { throw new ProcessingException("Unable to serialize entity", se); } }
@Override public Response toResponse(NotSupportedException exception) { return ExceptionMapperUtils.buildResponse(exception, Response.Status.UNSUPPORTED_MEDIA_TYPE); }
/** * {@inheritDoc} */ @Override public Response toResponse(final NotSupportedException exception) { if (L.isDebugEnabled()) { L.debug(R.getString("D-REST-JERSEY-MAPPER#0009")); } ErrorMessage error = ErrorMessages.create(exception) .code(ErrorCode.UNSUPPORTED_MEDIA_TYPE.code()) .resolve() .get(); L.warn(error.log(), exception); return Response.status(exception.getResponse().getStatusInfo()) .entity(error) .type(MediaType.APPLICATION_JSON) .build(); }
private void send(Collection<Trace> traces) { try { apmApi.reportTraces(traces); } catch (NotFoundException | NotSupportedException cee) { // 404, 415 if (apmApi instanceof ApmApi0_3) { log.info("falling back to json"); fallbackTo0_2(); send(traces); } } catch (BadRequestException bre) { log.error("{}: {}", bre.getMessage(), traces); } }
@Override public Response toResponse(NotSupportedException e) { return Response.status(Response.Status.UNSUPPORTED_MEDIA_TYPE) .entity(new org.crunchytorch.coddy.application.data.Response(e.getMessage())) .type(MediaType.APPLICATION_JSON) .build(); }
private static <T> T handleErrorStatus(Response response) { final int status = response.getStatus(); switch (status) { case 400: throw new BadRequestException(response); case 401: throw new NotAuthorizedException(response); case 404: throw new NotFoundException(response); case 405: throw new NotAllowedException(response); case 406: throw new NotAcceptableException(response); case 415: throw new NotSupportedException(response); case 500: throw new InternalServerErrorException(response); case 503: throw new ServiceUnavailableException(response); default: break; } if (status >= 400 && status < 500){ throw new ClientErrorException(response); } else if (status >= 500) { throw new ServerErrorException(response); } throw new WebApplicationException(response); }
protected void bindExceptionhandlers(ApplicationBindingBuilder builder) { builder .addProviderInstance(new GenericJsonExceptionHandler<ResourceNotFoundException>(Response.Status.NOT_FOUND) { }) .addProviderInstance(new GenericJsonExceptionHandler<StorageFileNotFoundException>(Response.Status.NOT_FOUND) { }) .addProviderInstance(new GenericJsonExceptionHandler<ResourceConflictException>(Response.Status.CONFLICT) { }) .addProviderInstance(new GenericJsonExceptionHandler<NotSupportedException>(Response.Status.BAD_REQUEST) { }) .addProviderInstance(new GenericJsonExceptionHandler<IOException>(Response.Status.BAD_REQUEST) { }) // happens if input is not gzip .addProviderInstance(new GenericJsonExceptionHandler<ModelValidationException>(Response.Status.BAD_REQUEST) { }) .addProviderInstance(new GenericJsonExceptionHandler<ConfigException>(Response.Status.BAD_REQUEST) { }) .addProviderInstance(new GenericJsonExceptionHandler<IllegalArgumentException>(Response.Status.BAD_REQUEST) { }) .addProviderInstance(new GenericJsonExceptionHandler<ResourceLimitExceededException>(Response.Status.BAD_REQUEST) { }) ; }
/** * POST method for creating an instance of ReservationResource * * @param content representation for the new resource * @return an HTTP response with content of the created resource */ @POST @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) public Response create(String content) { throw new NotSupportedException(); }
@Override protected ApiErrorResponse toApiErrorResponse(NotSupportedException exception) { return new ApiErrorResponse( "The media type of the request body is unsupported.", getCode(), getLocationType(), "Content-Type" ); }
/** * @see DataValueDescriptor#setValueFromResultSet * */ public void setValueFromResultSet(ResultSet resultSet, int colNumber, boolean isNullable) throws SQLException { Array array = resultSet.getArray(colNumber); int type = array.getBaseType(); throw new NotSupportedException("still need to implement " + array + " : " + type); }
@Override public ServiceInstance updateInstance(ServiceInstance instance, Plan plan) { throw new NotSupportedException("Updating Service Instances is currently not supported"); }
@Override public APIError convert(NotSupportedException exception) { return super.convert(exception); }
@Override public ServiceResult delete(Server server){ throw new NotSupportedException("Delete Operation on Server object is not supported"); }
public boolean login(String server, String user, String pw, boolean rememberCredentials) throws ClientVersionNotSupportedException, LoginException, Exception { // try { if (!getTrpSets().isServerSideActivated()) { throw new NotSupportedException("Connecting to the server not supported yet!"); } storage.login(server, user, pw); if (rememberCredentials) { // store credentials on successful login logger.debug("storing credentials for user: " + user); TrpGuiPrefs.storeCredentials(user, pw); } TrpGuiPrefs.storeLastLogin(user); TrpGuiPrefs.storeLastAccountType(OAuthGuiUtil.TRANSKRIBUS_ACCOUNT_TYPE); storage.reloadCollections(); userCache.add(user); if (sessionExpired && !lastLoginServer.equals(server)) { closeCurrentDocument(true); } sessionExpired = false; lastLoginServer = server; return true; // } // catch (ClientVersionNotSupportedException e) { // DialogUtil.showErrorMessageBox(getShell(), "Version not supported anymore!", e.getMessage()); // logger.error(e.getMessage(), e); // return false; // } // catch (LoginException e) { // logout(true, false); // logger.error(e.getMessage(), e); // return false; // } // catch (Exception e) { // logout(true, false); // logger.error(e.getMessage(), e); // return false; // } // finally { // ui.updateLoginInfo(storage.isLoggedIn(), getCurrentUserName(), // storage.getCurrentServer()); // } }
@Test public void whenWebApplicationException_thenUnsupportedMediaType() { assertThat(mapper.toResponse(new NotSupportedException(Response.status(Status.UNSUPPORTED_MEDIA_TYPE).build())) .getStatus(), is(Status.UNSUPPORTED_MEDIA_TYPE.getStatusCode())); }
@Nonnull private PMessageDescriptor getDescriptorOrFail(Class<?> type) { PMessageDescriptor descriptor = getDescriptor(type); if (descriptor == null) throw new NotSupportedException("No providence descriptor for class " + type.getName()); return descriptor; }
@Override public void updateInPerspective(@NotNull ActionEvent event) { throw new NotSupportedException("Method isn't supported in current mode..."); }
@Override public void actionPerformed(ActionEvent e) { throw new NotSupportedException("Method isn't supported in current mode..."); }
@Override public void go(@NotNull AcceptsOneWidget container) { throw new NotSupportedException( "This method will be tested in the class which extends AbstractPerspective"); }
@Override public void setFeature(final FeatureWrapper feature) { throw new NotSupportedException(); }
public MicroserviceHttpRequest(Request request, MultivaluedMap<String, ?> formParams, Object postParams) { this.msf4jRequest = request; this.method = request.getHttpMethod(); this.isGetRequest = REQUEST_GET.equals(method); // process URI String rawUri = request.getUri(); int uriPathEndIndex = rawUri.indexOf('?'); String rawUriPath, rawQueryString; if (uriPathEndIndex == -1) { rawUriPath = rawUri; rawQueryString = null; } else { rawUriPath = rawUri.substring(0, uriPathEndIndex); rawQueryString = rawUri.substring(uriPathEndIndex + 1, rawUri.length()); } this.uri = QueryStringDecoder.decodeComponent(rawUriPath); this.contextPath = HttpRequest.getContextPath(this.uri); this.uriWithoutContextPath = HttpRequest.getUriWithoutContextPath(this.uri); this.queryString = rawQueryString; // Query string is not very useful, so we don't bother to decode it. if (rawQueryString != null) { HashMap<String, Object> map = new HashMap<>(); new QueryStringDecoder(rawQueryString, false).parameters() .forEach((key, value) -> map.put(key, (value.size() == 1) ? value.get(0) : value)); this.queryParams = map; } else { this.queryParams = Collections.emptyMap(); } // process headers and cookies this.headers = new HashMap<>(); request.getHeaders().getAll().forEach(header -> this.headers.put(header.getName(), header.getValue())); String cookieHeader = this.headers.get(HttpHeaders.COOKIE); this.cookies = (cookieHeader == null) ? Collections.emptyMap() : ServerCookieDecoder.STRICT.decode(cookieHeader).stream().collect(Collectors.toMap(Cookie::name, c -> c)); // process POST data if (formParams == null) { // This request is not a form POST submission. this.files = Collections.emptyMap(); if (postParams == null) { this.formParams = Collections.emptyMap(); } else { if (postParams instanceof List) { List<?> postParamsList = (List<?>) postParams; this.formParams = new HashMap<>(postParamsList.size()); for (int i = 0; i < postParamsList.size(); i++) { this.formParams.put(Integer.toString(i), postParamsList.get(i)); } } else if (postParams instanceof Map) { this.formParams = (Map<String, Object>) postParams; } else { throw new NotSupportedException( "Unsupported JSON data type. Expected Map or List. Instead found '" + postParams.getClass().getName() + "'."); } } } else { this.formParams = new HashMap<>(); this.files = new HashMap<>(); for (Map.Entry<String, ? extends List<?>> entry : formParams.entrySet()) { List<?> values = entry.getValue(); if (values.isEmpty()) { continue; } if (values.get(0) instanceof File) { this.files.put(entry.getKey(), (values.size() == 1) ? values.get(0) : values); } else { this.formParams.put(entry.getKey(), (values.size() == 1) ? values.get(0) : values); } } } }
@GET public EmptyTest exception() { throw new NotSupportedException(); }
/** * Traversing of subtree for requested values. * * @param node current node * @param pathSegments all path segments of request URI * @param currentSegment index of current path segment * @param path path to current node * @param resourceType type of resource * @return list of values gathered from cache tree as {@code List<Value>} */ private List<Value> traverseCacheTree(CacheTreeNode node, LinkedList<String> pathSegments, int currentSegment, String path, DataResourceType resourceType) { List<Value> valList = new LinkedList<Value>(); String pathSegment; if (currentSegment < pathSegments.size()) { pathSegment = pathSegments.get(currentSegment); } else { return valList; } Set<String> keys = new HashSet<String>(); if (pathSegment.equals("*")) { keys = node.getKeySet(); } else if (pathSegment.split(pandaSettings.getRangeDelimiterChar()).length == 2) { String[] token = pathSegment.split(pandaSettings.getRangeDelimiterChar()); keys = node.getKeySubset(token[0], token[1]); } else { keys = node.getKeySubset(pathSegment, pathSegment); } for (String key : keys) { String newPath; Object obj = node.getChild(key); if (obj instanceof Value) { newPath = handleOutputURI(path + "/" + key, resourceType); Value val = (Value) obj; val.setSubURI(newPath); valList.add(val); } else if (obj instanceof CacheTreeNode) { newPath = path + "/" + key; valList.addAll(traverseCacheTree((CacheTreeNode) obj, pathSegments, currentSegment + 1, newPath, resourceType)); } else { throw new NotSupportedException("Unknown node type in CacheTree!"); } } return valList; }
/** * Get start node for cache tree by traversing baseURI. * * @param pathSegments path segments of request URI * @param node current node * @param baseURI current determined baseURI * @param resourceType type of resource * @return start node for cache tree traversing as {@code CacheTreeNode} */ private CacheTreeNode getStartNode(LinkedList<String> pathSegments, CacheTreeNode node, StringBuilder baseURI, DataResourceType resourceType) { CacheTreeNode currentNode = node; baseURI.append("/"); int minBaseUriSegments = getMinBaseUriPathSegments(resourceType); int startSubUri = pathSegments.size() - getMinSubUriPathSegments(resourceType); Iterator<String> iter = pathSegments.iterator(); for (int count = 0; iter.hasNext(); count++) { String pathSegment = iter.next(); // get next child node if: // - it is the first node (head of resource subtree) // - path segment is not a bulk request // - current path segment is not part spared for subURI // - segment shall be ignored (e.g. inserted extra segments) if (((!pathSegment.equals("*") && pathSegment.split(pandaSettings.getRangeDelimiterChar()).length < 2 && count < startSubUri)) || count < minBaseUriSegments) { if (!currentNode.containsKey(pathSegment)) { throw new WebApplicationException(404); } Object obj = currentNode.getChild(pathSegment); if (obj instanceof CacheTreeNode) { currentNode = (CacheTreeNode) obj; baseURI.append(pathSegment + "/"); iter.remove(); } else { throw new NotSupportedException( "Starting node for traversion of CacheTree shall not be a leaf."); } } else { // bulk segment found, traversing will branch here break; } } return currentNode; }
public int enqueue(JobRequest jd) { throw new NotSupportedException(); }
@Override public int enqueue(String applicationName, String userName) { throw new NotSupportedException(); }
@Override public int getJobProgress(int jobId) { throw new NotSupportedException(); }
@Override public List<InputStream> getJobDeliverablesContent(int jobId) { throw new NotSupportedException(); }
@Override public Response toResponse( NotSupportedException e ) { logger.error( "Unsupported media type", e ); return toResponse( UNSUPPORTED_MEDIA_TYPE, e ); }
@Override public void writeArray(UnsafeArrayWriter unsafeArrayWriter, int ordinal) throws StandardException { throw new NotSupportedException("Nested Arrays Not Supported Currently"); }
@Override public void read(UnsafeArrayData unsafeArrayData, int ordinal) throws StandardException { throw new NotSupportedException("Nested Arrays Not Supported Currently"); }