Adding ContentType for working with accept header.
This commit is contained in:
bdc34
parent
f6db2b5469
commit
f13e2cb5b1
2 changed files with 788 additions and 16 deletions
753
webapp/src/edu/cornell/mannlib/vitro/webapp/web/ContentType.java
Normal file
753
webapp/src/edu/cornell/mannlib/vitro/webapp/web/ContentType.java
Normal file
|
|
@ -0,0 +1,753 @@
|
|||
package edu.cornell.mannlib.vitro.webapp.web;
|
||||
|
||||
/* Copyright (c) 2008 Google Inc.
|
||||
*
|
||||
* Licensed 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.
|
||||
*/
|
||||
|
||||
/*
|
||||
* The code in this file is from the Google data API project 1.40.3 on 2010-03-08.
|
||||
* See full license from gdata at bottom of this file.
|
||||
* The Vitro project only uses the method getBestContentType().
|
||||
*/
|
||||
|
||||
//package com.google.gdata.util;
|
||||
|
||||
//import com.google.gdata.client.Service;
|
||||
|
||||
import java.io.Serializable;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
/**
|
||||
* Simple class for parsing and generating Content-Type header values, per
|
||||
* RFC 2045 (MIME) and 2616 (HTTP 1.1).
|
||||
*
|
||||
*
|
||||
*/
|
||||
public class ContentType implements Serializable {
|
||||
|
||||
private static String TOKEN =
|
||||
"[\\p{ASCII}&&[^\\p{Cntrl} ;/=\\[\\]\\(\\)\\<\\>\\@\\,\\:\\\"\\?\\=]]+";
|
||||
|
||||
// Precisely matches a token
|
||||
private static Pattern TOKEN_PATTERN = Pattern.compile(
|
||||
"^" + TOKEN + "$");
|
||||
|
||||
// Matches a media type value
|
||||
private static Pattern TYPE_PATTERN = Pattern.compile(
|
||||
"(" + TOKEN + ")" + // type (G1)
|
||||
"/" + // separator
|
||||
"(" + TOKEN + ")" + // subtype (G2)
|
||||
"\\s*(.*)\\s*", Pattern.DOTALL);
|
||||
|
||||
// Matches an attribute value
|
||||
private static Pattern ATTR_PATTERN = Pattern.compile(
|
||||
"\\s*;\\s*" +
|
||||
"(" + TOKEN + ")" + // attr name (G1)
|
||||
"\\s*=\\s*" +
|
||||
"(?:" +
|
||||
"\"([^\"]*)\"" + // value as quoted string (G3)
|
||||
"|" +
|
||||
"(" + TOKEN + ")?" + // value as token (G2)
|
||||
")"
|
||||
);
|
||||
|
||||
/**
|
||||
* Name of the attribute that contains the encoding character set for
|
||||
* the content type.
|
||||
* @see #getCharset()
|
||||
*/
|
||||
public static final String ATTR_CHARSET = "charset";
|
||||
|
||||
/**
|
||||
* Special "*" character to match any type or subtype.
|
||||
*/
|
||||
private static final String STAR = "*";
|
||||
|
||||
/**
|
||||
* The UTF-8 charset encoding is used by default for all text and xml
|
||||
* based MIME types.
|
||||
*/
|
||||
private static final String DEFAULT_CHARSET = ATTR_CHARSET + "=UTF-8";
|
||||
|
||||
/**
|
||||
* A ContentType constant that describes the base unqualified Atom content
|
||||
* type.
|
||||
*/
|
||||
public static final ContentType ATOM =
|
||||
new ContentType("application/atom+xml;" + DEFAULT_CHARSET).lock();
|
||||
|
||||
/**
|
||||
* A ContentType constant that describes the qualified Atom entry content
|
||||
* type.
|
||||
*
|
||||
* @see #getAtomEntry()
|
||||
*/
|
||||
public static final ContentType ATOM_ENTRY =
|
||||
new ContentType("application/atom+xml;type=entry;" + DEFAULT_CHARSET)
|
||||
.lock();
|
||||
|
||||
/**
|
||||
* A ContentType constant that describes the qualified Atom feed content
|
||||
* type.
|
||||
*
|
||||
* @see #getAtomFeed()
|
||||
*/
|
||||
public static final ContentType ATOM_FEED =
|
||||
new ContentType("application/atom+xml;type=feed;" + DEFAULT_CHARSET)
|
||||
.lock();
|
||||
|
||||
/**
|
||||
* Returns the ContentType that should be used in contexts that expect
|
||||
* an Atom entry.
|
||||
*/
|
||||
public static ContentType getAtomEntry() {
|
||||
// Use the unqualifed type for v1, the qualifed one for later versions
|
||||
//return Service.getVersion().isCompatible(Service.Versions.V1) ?
|
||||
// ATOM : ATOM_ENTRY;
|
||||
return ATOM_ENTRY;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the ContentType that should be used in contexts that expect
|
||||
* an Atom feed.
|
||||
*/
|
||||
public static ContentType getAtomFeed() {
|
||||
// Use the unqualified type for v1, the qualified one for later versions
|
||||
//return Service.getVersion().isCompatible(Service.Versions.V1) ?
|
||||
// ATOM : ATOM_FEED;
|
||||
return ATOM_FEED;
|
||||
}
|
||||
|
||||
/**
|
||||
* A ContentType constant that describes the Atom Service content type.
|
||||
*/
|
||||
public static final ContentType ATOM_SERVICE =
|
||||
new ContentType("application/atomsvc+xml;" + DEFAULT_CHARSET).lock();
|
||||
|
||||
/**
|
||||
* A ContentType constant that describes the RSS channel/item content type.
|
||||
*/
|
||||
public static final ContentType RSS =
|
||||
new ContentType("application/rss+xml;" + DEFAULT_CHARSET).lock();
|
||||
|
||||
/**
|
||||
* A ContentType constant that describes the JSON content type.
|
||||
*/
|
||||
public static final ContentType JSON =
|
||||
new ContentType("application/json;" + DEFAULT_CHARSET).lock();
|
||||
|
||||
/**
|
||||
* A ContentType constant that describes the Javascript content type.
|
||||
*/
|
||||
public static final ContentType JAVASCRIPT =
|
||||
new ContentType("text/javascript;" + DEFAULT_CHARSET).lock();
|
||||
|
||||
/**
|
||||
* A ContentType constant that describes the generic text/xml content type.
|
||||
*/
|
||||
public static final ContentType TEXT_XML =
|
||||
new ContentType("text/xml;" + DEFAULT_CHARSET).lock();
|
||||
|
||||
/**
|
||||
* A ContentType constant that describes the generic text/html content type.
|
||||
*/
|
||||
public static final ContentType TEXT_HTML =
|
||||
new ContentType("text/html;" + DEFAULT_CHARSET).lock();
|
||||
|
||||
/**
|
||||
* A ContentType constant that describes the generic text/plain content type.
|
||||
*/
|
||||
public static final ContentType TEXT_PLAIN =
|
||||
new ContentType("text/plain;" + DEFAULT_CHARSET).lock();
|
||||
|
||||
/**
|
||||
* A ContentType constant that describes the GData error content type.
|
||||
*/
|
||||
public static final ContentType GDATA_ERROR =
|
||||
new ContentType("application/vnd.google.gdata.error+xml").lock();
|
||||
|
||||
/**
|
||||
* A ContentType constant that describes the OpenSearch description document
|
||||
*/
|
||||
public static final ContentType OPENSEARCH =
|
||||
new ContentType("application/opensearchdescription+xml").lock();
|
||||
|
||||
|
||||
/**
|
||||
* A ContentType constant that describes the MIME multipart/related content
|
||||
* type.
|
||||
*/
|
||||
public static final ContentType MULTIPART_RELATED =
|
||||
new ContentType("multipart/related").lock();
|
||||
|
||||
/**
|
||||
* A ContentType constant that describes the application/xml content
|
||||
* type.
|
||||
*/
|
||||
public static final ContentType APPLICATION_XML =
|
||||
new ContentType("application/xml").lock();
|
||||
|
||||
/**
|
||||
* A ContentType constant that indicates that the body contains an
|
||||
* encapsulated message, with the syntax of an RFC 822 email message.
|
||||
*/
|
||||
public static final ContentType MESSAGE_RFC822 =
|
||||
new ContentType("message/rfc822").lock();
|
||||
|
||||
/**
|
||||
* Wildcard content type that will match any MIME type
|
||||
*/
|
||||
public static final ContentType ANY = new ContentType("*/*").lock();
|
||||
|
||||
/**
|
||||
* Determines the best "Content-Type" header to use in a servlet response
|
||||
* based on the "Accept" header from a servlet request.
|
||||
*
|
||||
* @param acceptHeader "Accept" header value from a servlet request (not
|
||||
* <code>null</code>)
|
||||
* @param actualContentTypes actual content types in descending order of
|
||||
* preference (non-empty, and each entry is of the
|
||||
* form "type/subtype" without the wildcard char
|
||||
* '*') or <code>null</code> if no "Accept" header
|
||||
* was specified
|
||||
* @return the best content type to use (or <code>null</code> on no match).
|
||||
*/
|
||||
public static ContentType getBestContentType(String acceptHeader,
|
||||
List<ContentType> actualContentTypes) {
|
||||
|
||||
// If not accept header is specified, return the first actual type
|
||||
if (acceptHeader == null) {
|
||||
return actualContentTypes.get(0);
|
||||
}
|
||||
|
||||
// iterate over all of the accepted content types to find the best match
|
||||
float bestQ = 0;
|
||||
ContentType bestContentType = null;
|
||||
String[] acceptedTypes = acceptHeader.split(",");
|
||||
for (String acceptedTypeString : acceptedTypes) {
|
||||
|
||||
// create the content type object
|
||||
ContentType acceptedContentType;
|
||||
try {
|
||||
acceptedContentType = new ContentType(acceptedTypeString.trim());
|
||||
} catch (IllegalArgumentException ex) {
|
||||
// ignore exception
|
||||
continue;
|
||||
}
|
||||
|
||||
// parse the "q" value (default of 1)
|
||||
float curQ = 1;
|
||||
try {
|
||||
String qAttr = acceptedContentType.getAttribute("q");
|
||||
if (qAttr != null) {
|
||||
float qValue = Float.valueOf(qAttr);
|
||||
if (qValue <= 0 || qValue > 1) {
|
||||
continue;
|
||||
}
|
||||
curQ = qValue;
|
||||
}
|
||||
} catch (NumberFormatException ex) {
|
||||
// ignore exception
|
||||
continue;
|
||||
}
|
||||
|
||||
// only check it if it's at least as good ("q") as the best one so far
|
||||
if (curQ < bestQ) {
|
||||
continue;
|
||||
}
|
||||
|
||||
/* iterate over the actual content types in order to find the best match
|
||||
to the current accepted content type */
|
||||
for (ContentType actualContentType : actualContentTypes) {
|
||||
|
||||
/* if the "q" value is the same as the current best, only check for
|
||||
better content types */
|
||||
if (curQ == bestQ && bestContentType == actualContentType) {
|
||||
break;
|
||||
}
|
||||
|
||||
/* check if the accepted content type matches the current actual
|
||||
content type */
|
||||
if (actualContentType.match(acceptedContentType)) {
|
||||
bestContentType = actualContentType;
|
||||
bestQ = curQ;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// if found an acceptable content type, return the best one
|
||||
if (bestQ != 0) {
|
||||
return bestContentType;
|
||||
}
|
||||
|
||||
// Return null if no match
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs a new instance with default media type
|
||||
*/
|
||||
public ContentType() {
|
||||
this(null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs a new instance from a content-type header value
|
||||
* parsing the MIME content type (RFC2045) format. If the type
|
||||
* is {@code null}, then media type and charset will be
|
||||
* initialized to default values.
|
||||
*
|
||||
* @param typeHeader content type value in RFC2045 header format.
|
||||
*/
|
||||
public ContentType(String typeHeader) {
|
||||
|
||||
// If the type header is no provided, then use the HTTP defaults.
|
||||
if (typeHeader == null) {
|
||||
type = "application";
|
||||
subType = "octet-stream";
|
||||
attributes.put(ATTR_CHARSET, "iso-8859-1"); // http default
|
||||
return;
|
||||
}
|
||||
|
||||
// Get type and subtype
|
||||
Matcher typeMatch = TYPE_PATTERN.matcher(typeHeader);
|
||||
if (!typeMatch.matches()) {
|
||||
throw new IllegalArgumentException("Invalid media type:" + typeHeader);
|
||||
}
|
||||
|
||||
type = typeMatch.group(1).toLowerCase();
|
||||
subType = typeMatch.group(2).toLowerCase();
|
||||
if (typeMatch.groupCount() < 3) {
|
||||
return;
|
||||
}
|
||||
|
||||
// Get attributes (if any)
|
||||
Matcher attrMatch = ATTR_PATTERN.matcher(typeMatch.group(3));
|
||||
while (attrMatch.find()) {
|
||||
|
||||
String value = attrMatch.group(2);
|
||||
if (value == null) {
|
||||
value = attrMatch.group(3);
|
||||
if (value == null) {
|
||||
value = "";
|
||||
}
|
||||
}
|
||||
|
||||
attributes.put(attrMatch.group(1).toLowerCase(), value);
|
||||
}
|
||||
|
||||
// Infer a default charset encoding if unspecified.
|
||||
if (!attributes.containsKey(ATTR_CHARSET)) {
|
||||
inferredCharset = true;
|
||||
if (subType.endsWith("xml")) {
|
||||
if (type.equals("application")) {
|
||||
// BUGBUG: Actually have need to look at the raw stream here, but
|
||||
// if client omitted the charset for "application/xml", they are
|
||||
// ignoring the STRONGLY RECOMMEND language in RFC 3023, sec 3.2.
|
||||
// I have little sympathy.
|
||||
attributes.put(ATTR_CHARSET, "utf-8"); // best guess
|
||||
} else {
|
||||
attributes.put(ATTR_CHARSET, "us-ascii"); // RFC3023, sec 3.1
|
||||
}
|
||||
} else if (subType.equals("json")) {
|
||||
attributes.put(ATTR_CHARSET, "utf-8"); // RFC4627, sec 3
|
||||
} else {
|
||||
attributes.put(ATTR_CHARSET, "iso-8859-1"); // http default
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/** {@code true} if parsed input didn't contain charset encoding info */
|
||||
private boolean inferredCharset = false;
|
||||
|
||||
/** If set to {@code true}, the object is immutable. */
|
||||
private boolean locked;
|
||||
|
||||
private String type;
|
||||
public String getType() { return type; }
|
||||
public void setType(String type) {
|
||||
assertNotLocked();
|
||||
this.type = type;
|
||||
}
|
||||
|
||||
|
||||
private String subType;
|
||||
public String getSubType() { return subType; }
|
||||
public void setSubType(String subType) {
|
||||
assertNotLocked();
|
||||
this.subType = subType;
|
||||
}
|
||||
|
||||
/** Returns the full media type */
|
||||
public String getMediaType() {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
sb.append(type);
|
||||
sb.append("/");
|
||||
sb.append(subType);
|
||||
if (attributes.containsKey("type")) {
|
||||
sb.append(";type=").append(attributes.get("type"));
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
private HashMap<String, String> attributes = new HashMap<String, String>();
|
||||
|
||||
/**
|
||||
* Makes the object immutable and returns it.
|
||||
*
|
||||
* This should at least be used when keeping a {@link ContentType} instance as
|
||||
* a static.
|
||||
*/
|
||||
public ContentType lock() {
|
||||
locked = true;
|
||||
return this;
|
||||
}
|
||||
|
||||
private void assertNotLocked() {
|
||||
if (locked) {
|
||||
throw new IllegalStateException("Unmodifiable instance");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the additional attributes of the content type.
|
||||
*/
|
||||
public Map<String, String> getAttributes() {
|
||||
if (locked) {
|
||||
return Collections.unmodifiableMap(attributes);
|
||||
}
|
||||
return attributes;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the additional attribute by name of the content type.
|
||||
*
|
||||
* @param name attribute name
|
||||
*/
|
||||
public String getAttribute(String name) {
|
||||
return attributes.get(name);
|
||||
}
|
||||
|
||||
/*
|
||||
* Returns the charset attribute of the content type or null if the
|
||||
* attribute has not been set.
|
||||
*/
|
||||
public String getCharset() { return attributes.get(ATTR_CHARSET); }
|
||||
|
||||
|
||||
/**
|
||||
* Returns whether this content type is match by the content type found in the
|
||||
* "Accept" header field of an HTTP request.
|
||||
*
|
||||
* <p>For atom content type, this method will check the optional attribute
|
||||
* 'type'. If the type attribute is set in both this and {@code
|
||||
* acceptedContentType}, then they must be the same. That is, {@code
|
||||
* application/atom+xml} will match both {@code
|
||||
* application/atom+xml;type=feed} and {@code
|
||||
* application/atom+xml;type=entry}, but {@code
|
||||
* application/atom+xml;type=entry} will not match {@code
|
||||
* application/atom+xml;type=feed}.a
|
||||
*
|
||||
* @param acceptedContentType content type found in the "Accept" header field
|
||||
* of an HTTP request
|
||||
*/
|
||||
public boolean match(ContentType acceptedContentType) {
|
||||
String acceptedType = acceptedContentType.getType();
|
||||
String acceptedSubType = acceptedContentType.getSubType();
|
||||
return STAR.equals(acceptedType) || type.equals(acceptedType)
|
||||
&& (STAR.equals(acceptedSubType) || subType.equals(acceptedSubType))
|
||||
&& (!isAtom() || matchAtom(acceptedContentType));
|
||||
}
|
||||
|
||||
/** Returns true if this is an atom content type. */
|
||||
private boolean isAtom() {
|
||||
return "application".equals(type) && "atom+xml".equals(subType);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compares the optional 'type' attribute of two content types.
|
||||
*
|
||||
* <p>This method accepts atom content type without the 'type' attribute
|
||||
* but if the types are specified, they must match.
|
||||
*/
|
||||
private boolean matchAtom(ContentType acceptedContentType) {
|
||||
String atomType = getAttribute("type");
|
||||
String acceptedAtomType = acceptedContentType.getAttribute("type");
|
||||
|
||||
return atomType == null || acceptedAtomType == null
|
||||
|| atomType.equals(acceptedAtomType);
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates the Content-Type value
|
||||
*/
|
||||
@Override
|
||||
public String toString() {
|
||||
|
||||
StringBuffer sb = new StringBuffer();
|
||||
sb.append(type);
|
||||
sb.append("/");
|
||||
sb.append(subType);
|
||||
for (String name : attributes.keySet()) {
|
||||
|
||||
// Don't include any inferred charset attribute in output.
|
||||
if (inferredCharset && ATTR_CHARSET.equals(name)) {
|
||||
continue;
|
||||
}
|
||||
sb.append(";");
|
||||
sb.append(name);
|
||||
sb.append("=");
|
||||
String value = attributes.get(name);
|
||||
Matcher tokenMatcher = TOKEN_PATTERN.matcher(value);
|
||||
if (tokenMatcher.matches()) {
|
||||
sb.append(value);
|
||||
} else {
|
||||
sb.append("\"" + value + "\"");
|
||||
}
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public boolean equals(Object o) {
|
||||
if (this == o) {
|
||||
return true;
|
||||
}
|
||||
if (o == null || getClass() != o.getClass()) {
|
||||
return false;
|
||||
}
|
||||
ContentType that = (ContentType) o;
|
||||
return type.equals(that.type) && subType.equals(that.subType) && attributes
|
||||
.equals(that.attributes);
|
||||
}
|
||||
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return (type.hashCode() * 31 + subType.hashCode()) * 31 + attributes
|
||||
.hashCode();
|
||||
}
|
||||
}
|
||||
/*
|
||||
|
||||
|
||||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright [yyyy] [name of copyright owner]
|
||||
|
||||
Licensed 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.
|
||||
*/
|
||||
|
|
@ -2,21 +2,19 @@
|
|||
|
||||
package edu.cornell.mannlib.vitro.webapp.web;
|
||||
|
||||
import java.util.Enumeration;
|
||||
import java.util.Properties;
|
||||
|
||||
import javax.servlet.ServletRequest;
|
||||
import javax.servlet.http.HttpServletRequest;
|
||||
import javax.servlet.jsp.JspException;
|
||||
|
||||
import org.apache.commons.lang.StringEscapeUtils;
|
||||
import org.apache.commons.logging.Log;
|
||||
import org.apache.commons.logging.LogFactory;
|
||||
|
||||
import com.hp.hpl.jena.rdf.model.Model;
|
||||
import com.hp.hpl.jena.rdf.model.impl.ModelCom;
|
||||
|
||||
import edu.cornell.mannlib.vitro.webapp.auth.policy.JenaNetidPolicy.ContextSetup;
|
||||
import java.util.Enumeration;
|
||||
import java.util.Properties;
|
||||
|
||||
import javax.servlet.ServletRequest;
|
||||
import javax.servlet.http.HttpServletRequest;
|
||||
import javax.servlet.jsp.JspException;
|
||||
|
||||
import org.apache.commons.lang.StringEscapeUtils;
|
||||
import org.apache.commons.logging.Log;
|
||||
import org.apache.commons.logging.LogFactory;
|
||||
|
||||
import com.hp.hpl.jena.rdf.model.Model;
|
||||
import com.hp.hpl.jena.rdf.model.impl.ModelCom;
|
||||
|
||||
public class MiscWebUtils {
|
||||
/**
|
||||
|
|
@ -170,7 +168,28 @@ public class MiscWebUtils {
|
|||
}
|
||||
return rv;
|
||||
}
|
||||
|
||||
|
||||
|
||||
public static void debugPrintHeaders(HttpServletRequest req){
|
||||
Enumeration hnames = req.getHeaderNames();
|
||||
while( hnames.hasMoreElements() ){
|
||||
String name = (String) hnames.nextElement();
|
||||
System.out.println("header " + name);
|
||||
String value = req.getHeader(name);
|
||||
System.out.println(" " + value);
|
||||
Enumeration values = req.getHeaders(name);
|
||||
if( values == null ){
|
||||
System.out.println(" enumeration was null");
|
||||
}else{
|
||||
System.out.println(" enumeration values");
|
||||
while( values.hasMoreElements() ){
|
||||
String val = (String) values.nextElement();
|
||||
System.out.println(" " + value);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
This isfrom org.json.simple.JSONObject
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue