/*
* 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.abdera.protocol.server;
import java.io.IOException;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import javax.activation.MimeType;
import javax.xml.namespace.QName;
import org.apache.abdera.Abdera;
import org.apache.abdera.i18n.iri.IRI;
import org.apache.abdera.i18n.text.Localizer;
import org.apache.abdera.i18n.text.Sanitizer;
import org.apache.abdera.model.AtomDate;
import org.apache.abdera.model.Base;
import org.apache.abdera.model.Content;
import org.apache.abdera.model.Document;
import org.apache.abdera.model.Element;
import org.apache.abdera.model.Entry;
import org.apache.abdera.model.ExtensibleElement;
import org.apache.abdera.model.Feed;
import org.apache.abdera.model.Link;
import org.apache.abdera.protocol.error.Error;
import org.apache.abdera.protocol.server.context.AbstractResponseContext;
import org.apache.abdera.protocol.server.context.BaseResponseContext;
import org.apache.abdera.protocol.server.context.EmptyResponseContext;
import org.apache.abdera.protocol.server.context.StreamWriterResponseContext;
import org.apache.abdera.util.Constants;
import org.apache.abdera.util.EntityTag;
import org.apache.abdera.util.MimeTypeHelper;
import org.apache.abdera.writer.NamedWriter;
import org.apache.abdera.writer.StreamWriter;
import org.apache.abdera.writer.WriterFactory;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
* Provides support methods for {@link Provider}
*/
public class ProviderHelper {
private 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 AbstractResponseContext createErrorResponse(
Abdera abdera,
final int code,
final String message) {
return createErrorResponse(abdera,code,message,null);
}
/**
* Returns an Error document based on the StreamWriter
*/
public static AbstractResponseContext createErrorResponse(
Abdera abdera,
final int code,
final String message,
final Throwable t) {
AbstractResponseContext rc =
new StreamWriterResponseContext(abdera) {
protected void writeTo(StreamWriter sw)
throws IOException {
Error.create(sw, code, message, t);
}
};
rc.setStatus(code);
rc.setStatusText(message);
return rc;
}
/**
* Return a server error
*/
public static ResponseContext servererror(
RequestContext request,
String reason,
Throwable t) {
log.info(Localizer.get("SERVER_ERROR"), t);
return createErrorResponse(request.getAbdera(),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.getAbdera(),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.getAbdera(),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.getAbdera(),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"));
AbstractResponseContext resp =
createErrorResponse(request.getAbdera(),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.getAbdera(),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.getAbdera(),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.getAbdera(),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.getAbdera(),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.getAbdera(),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.getAbdera(),423,reason);
}
public static ResponseContext locked(
RequestContext request) {
return locked(request, "Locked");
}
/**
* Return a document
*/
@SuppressWarnings("unchecked")
public static ResponseContext returnBase(
Base base,
int status,
Date lastModified) {
log.debug(Localizer.get("RETURNING.DOCUMENT"));
BaseResponseContext response = new BaseResponseContext(base);
response.setStatus(status);
if (lastModified != null) response.setLastModified(lastModified);
response.setContentType(MimeTypeHelper.getMimeType(base));
Document doc = base instanceof Document ? (Document)base : ((Element)base).getDocument();
if (doc.getEntityTag() != null) {
response.setEntityTag(doc.getEntityTag());
} else if (doc.getLastModified() != null) {
response.setLastModified(doc.getLastModified());
}
return response;
}
/**
* 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 = Sanitizer.sanitize(slug);
log.debug(Localizer.sprintf("SLUG.SANITIZED", slug, sanitized));
return sanitized;
}
/**
* Check to see if the entry is minimally valid according to RFC4287.
* This is not a complete check. It just verifies that the appropriate
* elements are present and that their values can be accessed.
*/
public static boolean isValidEntry(Entry entry) {
try {
IRI id = entry.getId();
if (id == null ||
id.toString().trim().length() == 0 ||
!id.isAbsolute()) return false;
if (entry.getTitle() == null) return false;
if (entry.getUpdated() == null) return false;
if (entry.getAuthor() == null &&
(entry.getSource() != null &&
entry.getSource().getAuthor() == null)) return false;
Content content = entry.getContentElement();
if (content == null) {
if (entry.getAlternateLink() == null) return false;
} else {
if ((content.getSrc() != null ||
content.getContentType() == Content.Type.MEDIA) &&
entry.getSummaryElement() == null) {
log.debug(Localizer.sprintf("CHECKING.VALID.ENTRY",false));
return false;
}
}
} catch (Exception e) {
log.debug(Localizer.sprintf("CHECKING.VALID.ENTRY",false));
return false;
}
log.debug(Localizer.sprintf("CHECKING.VALID.ENTRY",true));
return true;
}
/**
* Return false if the element contains any extension elements that are not
* supported
*/
public static boolean checkElementNamespaces(
Element element,
List<String> ignore) {
List<QName> attrs = element.getExtensionAttributes();
for (QName qname : attrs) {
String ns = qname.getNamespaceURI();
if (!ignore.contains(ns)) return false;
}
if (element instanceof ExtensibleElement) {
ExtensibleElement ext = (ExtensibleElement) element;
List<Element> extensions = ext.getExtensions();
for (Element el : extensions) {
QName qname = el.getQName();
String ns = qname.getNamespaceURI();
if (!ignore.contains(ns)) return false;
if (!checkElementNamespaces(el, ignore)) return false;
}
}
return true;
}
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);
}
private static class QTokenComparator
implements Comparator<QToken> {
public int compare(QToken o1, QToken o2) {
if (o1.qvalue > o2.qvalue)
return -1;
if (o1.qvalue < o2.qvalue)
return 1;
return 0;
}
}
private static class QToken {
String token;
double qvalue = 1.0;
QToken(String token,double qvalue) {
this.token = token;
this.qvalue = qvalue;
}
}
/**
* <p>Utility method for parsing HTTP content negotiation headers and sorting
* their tokens according to their q parameter values.</p>
*
* <p>e.g. Accept: audio/*; q=0.2, audio/basic, audio/mpeg; q=0.1</p>
*
* <p>would sort into:</p>
* <pre>
* audio/basic
* audio/*
* audio/mpeg
* </pre>
*/
public static String[] orderByQ(String header) {
if (header == null || header.length() == 0) return new String[0];
String[] tokens = header.split(",");
QToken[] qtokens = new QToken[tokens.length];
for (int i = 0; i < tokens.length; i++) {
String token = tokens[i];
String[] qvalues = token.trim().split(";");
String t = qvalues[0];
if (qvalues.length > 1) {
for (int n = 1; n < qvalues.length; n++) {
String[] v = qvalues[n].trim().split("=");
if (v[0].trim().equals("q")) {
double qv = Double.parseDouble(v[1]);
qtokens[i] = new QToken(t,qv);
break;
}
}
}
if (qtokens[i] == null) qtokens[i] = new QToken(t,1.0);
}
Arrays.sort(qtokens, new QTokenComparator());
tokens = new String[qtokens.length];
for (int n = 0; n < qtokens.length; n++) {
tokens[n] = qtokens[n].token;
}
return tokens;
}
/**
* Returns an appropriate NamedWriter instance given an appropriately
* formatted HTTP Accept header. The header will be parsed and sorted
* according to it's q parameter values. The first named writer capable
* of supporting the specified type, in order of q-value preference, will
* be returned. The results on this are not always predictable. For instance,
* if the Accept header says "application/*" it could end up with either the
* JSON writer or the PrettyXML writer, or any other writer that supports
* any writer that supports a specific form of "application/*". It's always
* best to be very specific in the Accept headers.
*/
public static NamedWriter getAcceptableNamedWriter(
Abdera abdera, String accept_header) {
String[] sorted_accepts = orderByQ(accept_header);
WriterFactory factory = abdera.getWriterFactory();
if (factory == null) return null;
for (String accept : sorted_accepts) {
NamedWriter writer = (NamedWriter) factory.getWriterByMediaType(accept);
if (writer != null) return writer;
}
return null;
}
public static NamedWriter getNamedWriter(Abdera abdera, String mediatype) {
WriterFactory factory = abdera.getWriterFactory();
if (factory == null) return null;
NamedWriter writer = (NamedWriter) factory.getWriterByMediaType(mediatype);
return writer;
}
public static EntityTag calculateEntityTag(Base base) {
String id = null;
String modified = null;
if (base instanceof Entry) {
Entry entry = (Entry) base;
id = entry.getId().toString();
modified =
AtomDate.format(
entry.getEdited() != null ?
entry.getEdited() :
entry.getUpdated()
);
} else if (base instanceof Feed) {
Feed feed = (Feed) base;
id = feed.getId().toString();
modified = AtomDate.format(feed.getUpdated());
} else if (base instanceof Document) {
return calculateEntityTag(((Document<?>)base).getRoot());
}
return EntityTag.generate(id, modified);
}
public static String getEditUriFromEntry(
Entry entry) {
String editUri = null;
List<Link> editLinks = entry.getLinks("edit");
if (editLinks != null) {
for (Link link : editLinks) {
// if there is more than one edit link, we should not automatically
// assume that it's always going to point to an Atom document
// representation.
if (link.getMimeType() != null) {
if (MimeTypeHelper.isMatch(
link.getMimeType().toString(),
Constants.ATOM_MEDIA_TYPE)) {
editUri = link.getResolvedHref().toString();
break;
}
} else {
// edit link with no type attribute is the right one to use
editUri = link.getResolvedHref().toString();
break;
}
}
}
return editUri;
}
public static String[] getAcceptableTypes(
RequestContext request) {
String accept = request.getAccept();
return orderByQ(accept);
}
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;
}
}