| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. 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. For additional information regarding |
| * copyright in this work, please see the NOTICE file in the top level |
| * directory of this distribution. |
| */ |
| package org.apache.abdera2.common.protocol; |
| |
| import java.util.Date; |
| |
| import javax.activation.MimeType; |
| |
| import org.apache.abdera2.common.Localizer; |
| import org.apache.abdera2.common.iri.IRI; |
| import org.apache.abdera2.common.text.Slug; |
| import org.apache.abdera2.common.http.QualityHelper; |
| import org.apache.abdera2.common.http.QualityHelper.QToken; |
| import org.apache.abdera2.common.mediatype.MimeTypeHelper; |
| import org.apache.commons.logging.Log; |
| import org.apache.commons.logging.LogFactory; |
| |
| public class ProviderHelper { |
| public final static Log log = LogFactory.getLog(ProviderHelper.class); |
| |
| private ProviderHelper() { |
| } |
| |
| public static int getPageSize(RequestContext request, String pagesizeparam, int defaultpagesize) { |
| int size = defaultpagesize; |
| try { |
| String _ps = request.getParameter(pagesizeparam); |
| size = (_ps != null) ? Math.min(Math.max(Integer.parseInt(_ps), 0), defaultpagesize) : defaultpagesize; |
| } catch (Exception e) { |
| } |
| log.debug(Localizer.sprintf("PAGE.SIZE", size)); |
| return size; |
| } |
| |
| public static int getOffset(RequestContext request, String pageparam, int pageSize) { |
| int offset = 0; |
| try { |
| String _page = request.getParameter(pageparam); |
| int page = (_page != null) ? Integer.parseInt(_page) : 1; |
| page = Math.max(page, 1) - 1; |
| offset = pageSize * page; |
| } catch (Exception e) { |
| } |
| log.debug(Localizer.sprintf("OFFSET", offset)); |
| return offset; |
| } |
| |
| /** |
| * Returns an Error document based on the StreamWriter |
| */ |
| public static ResponseContext createErrorResponse(Provider provider, final int code, final String message) { |
| return createErrorResponse(provider, code, message, null); |
| } |
| |
| /** |
| * Returns an Error document based on the StreamWriter |
| */ |
| public static ResponseContext createErrorResponse(Provider provider, |
| final int code, |
| final String message, |
| final Throwable t) { |
| return (ResponseContext)provider.createErrorResponse(code, message, t); |
| } |
| |
| /** |
| * Return a server error |
| */ |
| public static ResponseContext servererror(RequestContext request, String reason, Throwable t) { |
| log.info(Localizer.get("SERVER_ERROR"), t); |
| return createErrorResponse(request.getProvider(), 500, reason, t); |
| } |
| |
| /** |
| * Return a server error |
| */ |
| public static ResponseContext servererror(RequestContext request, Throwable t) {; |
| return servererror(request, "Server Error", t); |
| } |
| |
| /** |
| * Return an unauthorized error |
| */ |
| public static ResponseContext unauthorized(RequestContext request, String reason) { |
| log.debug(Localizer.get("UNAUTHORIZED")); |
| return createErrorResponse(request.getProvider(), 401, reason); |
| } |
| |
| public static ResponseContext unauthorized(RequestContext request) { |
| return unauthorized(request, "Unauthorized"); |
| } |
| |
| /** |
| * Return an unauthorized error |
| */ |
| public static ResponseContext forbidden(RequestContext request, String reason) { |
| log.debug(Localizer.get("FORBIDDEN")); |
| return createErrorResponse(request.getProvider(), 403, reason); |
| } |
| |
| public static ResponseContext forbidden(RequestContext request) { |
| return forbidden(request, "Forbidden"); |
| } |
| |
| /** |
| * Return a 204 No Content response |
| */ |
| public static ResponseContext nocontent(String reason) { |
| return new EmptyResponseContext(204, reason); |
| } |
| |
| public static ResponseContext nocontent() { |
| return nocontent("Not Content"); |
| } |
| |
| /** |
| * Return a 404 not found error |
| */ |
| public static ResponseContext notfound(RequestContext request, String reason) { |
| log.debug(Localizer.get("UNKNOWN")); |
| return createErrorResponse(request.getProvider(), 404, reason); |
| } |
| |
| public static ResponseContext notfound(RequestContext request) { |
| return notfound(request, "Not Found"); |
| } |
| |
| /** |
| * Return a 405 method not allowed error |
| */ |
| public static ResponseContext notallowed(RequestContext request, String reason, String... methods) { |
| log.debug(Localizer.get("NOT.ALLOWED")); |
| ResponseContext resp = createErrorResponse(request.getProvider(), 405, reason); |
| resp.setAllow(methods); |
| return resp; |
| } |
| |
| public static ResponseContext notallowed(RequestContext request, String... methods) { |
| return notallowed(request, "Method Not Allowed", methods); |
| } |
| |
| public static ResponseContext notallowed(RequestContext request) { |
| return notallowed(request, getDefaultMethods(request)); |
| } |
| |
| /** |
| * Return a 400 bad request error |
| */ |
| public static ResponseContext badrequest(RequestContext request, String reason) { |
| log.debug(Localizer.get("BAD.REQUEST")); |
| return createErrorResponse(request.getProvider(), 400, reason); |
| } |
| |
| public static ResponseContext badrequest(RequestContext request) { |
| return badrequest(request, "Bad Request"); |
| } |
| |
| /** |
| * Return a 409 conflict error |
| */ |
| public static ResponseContext conflict(RequestContext request, String reason) { |
| log.debug(Localizer.get("CONFLICT")); |
| return createErrorResponse(request.getProvider(), 409, reason); |
| } |
| |
| public static ResponseContext conflict(RequestContext request) { |
| return conflict(request, "Conflict"); |
| } |
| |
| /** |
| * Return a service unavailable error |
| */ |
| public static ResponseContext unavailable(RequestContext request, String reason) { |
| log.debug(Localizer.get("UNAVAILABLE")); |
| return createErrorResponse(request.getProvider(), 503, reason); |
| } |
| |
| public static ResponseContext unavailable(RequestContext request) { |
| return unavailable(request, "Service Unavailable"); |
| } |
| |
| public static ResponseContext notmodified(RequestContext request, String reason) { |
| log.debug(Localizer.get("NOT.MODIFIED")); |
| return new EmptyResponseContext(304, reason); |
| } |
| |
| public static ResponseContext notmodified(RequestContext request) { |
| return notmodified(request, "Not Modified"); |
| } |
| |
| public static ResponseContext preconditionfailed(RequestContext request, String reason) { |
| log.debug(Localizer.get("PRECONDITION.FAILED")); |
| return createErrorResponse(request.getProvider(), 412, reason); |
| } |
| |
| public static ResponseContext preconditionfailed(RequestContext request) { |
| return preconditionfailed(request, "Precondition Failed"); |
| } |
| |
| /** |
| * Return a 415 media type not-supported error |
| */ |
| public static ResponseContext notsupported(RequestContext request, String reason) { |
| log.debug(Localizer.get("NOT.SUPPORTED")); |
| return createErrorResponse(request.getProvider(), 415, reason); |
| } |
| |
| public static ResponseContext notsupported(RequestContext request) { |
| return notsupported(request, "Media Type Not Supported"); |
| } |
| |
| /** |
| * Return a 423 locked error |
| */ |
| public static ResponseContext locked(RequestContext request, String reason) { |
| log.debug(Localizer.get("LOCKED")); |
| return createErrorResponse(request.getProvider(), 423, reason); |
| } |
| |
| public static ResponseContext locked(RequestContext request) { |
| return locked(request, "Locked"); |
| } |
| |
| /** |
| * Sanitize the value of a Slug header. Any non alphanumeric characters in the slug are replaced with an underscore |
| */ |
| public static String sanitizeSlug(String slug) { |
| if (slug == null) |
| throw new IllegalArgumentException(Localizer.get("SLUG.NOT.NULL")); |
| String sanitized = Slug.create(slug).toString(); |
| log.debug(Localizer.sprintf("SLUG.SANITIZED", slug, sanitized)); |
| return sanitized; |
| } |
| |
| public static boolean beforeOrEqual(Date d1, Date d2) { |
| long l1 = d1.getTime() / 1000; // drop milliseconds |
| long l2 = d2.getTime() / 1000; // drop milliseconds |
| return l1 <= l2; |
| } |
| |
| public static IRI resolveBase(RequestContext request) { |
| return request.getBaseUri().resolve(request.getUri()); |
| } |
| |
| public static String combine(String... vals) { |
| StringBuilder buf = new StringBuilder(); |
| for (String val : vals) { |
| if (buf.length() > 0) |
| buf.append(", "); |
| buf.append(val); |
| } |
| return buf.toString(); |
| } |
| |
| public static String[] getDefaultMethods(RequestContext request) { |
| TargetType type = request.getTarget().getType(); |
| if (type == null) |
| return new String[0]; |
| if (type == TargetType.TYPE_COLLECTION) |
| return new String[] {"GET", "HEAD", "OPTIONS", "POST"}; |
| if (type == TargetType.TYPE_CATEGORIES) |
| return new String[] {"GET", "HEAD", "OPTIONS"}; |
| if (type == TargetType.TYPE_ENTRY) |
| return new String[] {"DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT"}; |
| if (type == TargetType.TYPE_MEDIA) |
| return new String[] {"DELETE", "GET", "HEAD", "OPTIONS", "POST", "PUT"}; |
| if (type == TargetType.TYPE_SERVICE) |
| return new String[] {"GET", "HEAD", "OPTIONS"}; |
| return new String[] {"GET", "HEAD", "OPTIONS"}; |
| } |
| |
| public static boolean defaultCheckMethod(RequestContext request, String[] methods) { |
| return (java.util.Arrays.binarySearch(methods, request.getMethod()) >= 0); |
| } |
| |
| public static boolean isAtom(RequestContext request) { |
| MimeType mt = request.getContentType(); |
| String ctype = (mt != null) ? mt.toString() : null; |
| return ctype != null && MimeTypeHelper.isAtom(ctype); |
| } |
| |
| public static String[] getAcceptableTypes(RequestContext request) { |
| String accept = request.getAccept(); |
| QToken[] tokens = QualityHelper.orderByQ(accept); |
| String[] res = new String[tokens.length]; |
| for (int n = 0; n < tokens.length; n++) |
| res[n] = tokens[n].token(); |
| return res; |
| } |
| |
| public static boolean isPreferred(RequestContext request, String s1, String s2) { |
| return isPreferred(getAcceptableTypes(request), s1, s2); |
| } |
| |
| public static boolean isPreferred(String[] accepts, String s1, String s2) { |
| int i1 = accepts.length, i2 = accepts.length; |
| for (int n = 0; n < accepts.length; n++) { |
| if (MimeTypeHelper.isMatch(s1, accepts[n])) { |
| i1 = n; |
| break; |
| } |
| } |
| for (int n = 0; n < accepts.length; n++) { |
| if (MimeTypeHelper.isMatch(s2, accepts[n])) { |
| i2 = n; |
| break; |
| } |
| } |
| return i1 < i2; |
| } |
| } |