/*
* Copyright 2000-2004 The Apache Software Foundation.
*
* 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.
*/
package org.apache.jetspeed.portal.portlets;
//Element Construction Set
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URL;
import java.net.URLConnection;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import org.apache.ecs.ConcreteElement;
import org.apache.jetspeed.portal.PortletConfig;
import org.apache.jetspeed.portal.PortletException;
import org.apache.jetspeed.services.Transformer;
import org.apache.jetspeed.util.Base64;
import org.apache.jetspeed.util.JetspeedClearElement;
import org.apache.turbine.services.servlet.TurbineServlet;
import org.apache.turbine.util.RunData;
import org.apache.jetspeed.services.logging.JetspeedLogFactoryService;
import org.apache.jetspeed.services.logging.JetspeedLogger;
/**
* A class that clips parts of one or more web pages.
*
* @author <a href="mailto:mmari@ce.unipr.it">Marco Mari</a>
* @version $Id: WebClippingPortlet.java,v 1.2 2004/02/23 04:03:34 jford Exp $
*/
public class WebClippingPortlet extends AbstractInstancePortlet
{
/**
* Static initialization of the logger for this class
*/
private static final JetspeedLogger logger =
JetspeedLogFactoryService.getLogger(WebClippingPortlet.class.getName());
// Define parameter name for the first tag to clip
public static final String START = "startTag";
// Define parameter name for the last tag to clip
public static final String STOP = "stopTag";
// Define parameter name for a single tag to clip
public static final String TAG = "Tag";
// Define parameter name for the number of the tag to clip
public static final String TAGNUM = "startTagNumber";
// Define parameter name for the URL of the page
public static final String URL = "url";
// Error message for startTag without stopTag
private String BAD_PARAM = "<br>Error: startTag without stopTag<br>";
// Error message for wrong startTagNumber parameter
private String BAD_NUMBER = "<br>Error: bad integer parameter<br>";
protected boolean initDone = false;
protected boolean contentStale = true;
protected boolean cacheContent = false;
protected String username = null;
protected String password = null;
private Hashtable patterns = null;
/**
* Initialize this portlet
* @throws PortletException Initialization failed
*/
public void init()
{
if (initDone)
return;
patterns = new Hashtable();
try
{
loadParams();
}
catch (Exception e)
{
logger.info("Exception occurred:" + e.toString());
e.printStackTrace();
}
contentStale = true;
initDone = true;
}
/**
* took this from FileServerPortlet as it was private
*
*/
// FIXME: Currently only the expiration the HTTP Response header is honored.
// Expiration information in <meta> tags are not honored
protected Reader getReader(String url) throws IOException
{
URL pageUrl = new URL(url);
URLConnection pageConn = pageUrl.openConnection();
try
{
// set HTTP Basic Authetication header if username and password are set
if (username != null && password != null)
{
pageConn.setRequestProperty(
"Authorization",
"Basic "
+ Base64.encodeAsString(username + ":" + password));
}
}
catch (Exception e)
{
logger.info("Exception occurred:" + e.toString());
e.printStackTrace();
}
long pageExpiration = pageConn.getExpiration();
String encoding = pageConn.getContentEncoding();
String tempString = null;
String noCache = "no-cache";
if (encoding == null)
{
// Standard HTTP encoding
encoding = "iso-8859-1";
}
/*
* Determing if content should be cached.
*/
cacheContent = true; // Assume content is cached
if (pageExpiration == 0)
{
cacheContent = false;
}
// Check header field CacheControl
tempString = pageConn.getHeaderField("Cache-Control");
if (tempString != null)
{
if (tempString.toLowerCase().indexOf(noCache) >= 0)
{
cacheContent = false;
}
}
// Check header field Pragma
tempString = pageConn.getHeaderField("Pragma");
if (tempString != null)
{
if (tempString.toLowerCase().indexOf(noCache) >= 0)
{
cacheContent = false;
}
}
// Assign a reader
Reader rdr = new InputStreamReader(pageConn.getInputStream(), encoding);
// Only set the page expiration it the page has not expired
if (pageExpiration > System.currentTimeMillis()
&& (cacheContent == true))
{
contentStale = false;
logger.debug(
"WebPagePortlet caching URL: "
+ url
+ " Expiration: "
+ pageExpiration
+ ", "
+ (pageExpiration - System.currentTimeMillis())
+ " milliseconds into the future");
setExpirationMillis(pageExpiration);
}
else
{
contentStale = true;
}
return rdr;
}
/**
This methods outputs the content of the portlet for a given
request.
@param data the RunData object for the request
@return the content to be displayed to the user-agent
*/
public ConcreteElement getContent(RunData data)
{
PortletConfig config = this.getPortletConfig();
if (contentStale == true)
return getWebClippedContent(data, config);
if (null == getExpirationMillis())
return getContent(data, null, true);
if (getExpirationMillis().longValue() <= System.currentTimeMillis())
return getWebClippedContent(data, config);
return getContent(data, null, true);
}
/*
* This method returns the clipped part of the Web page
*/
private ConcreteElement getWebClippedContent(
RunData data,
PortletConfig config)
{
String clippedString = ""; // HTML to visualize
JetspeedClearElement element = null;
int patternNumber = 1;
int tagNumber = 0;
Reader htmlReader;
String defaultUrl = selectUrl(data, config);
try
{
// Re-load parameters to see immediately the effect of changes
loadParams();
Enumeration en = patterns.keys();
while (en.hasMoreElements())
{
String name = (String) en.nextElement();
// Search for parameters in the right order
if (name.equals(START + String.valueOf(patternNumber))
|| name.equals(TAG + String.valueOf(patternNumber)))
{
String start =
(String) patterns.get(
START + String.valueOf(patternNumber));
String simpleTag =
(String) patterns.get(
TAG + String.valueOf(patternNumber));
String stop =
(String) patterns.get(
STOP + String.valueOf(patternNumber));
String tagNum =
(String) patterns.get(
TAGNUM + String.valueOf(patternNumber));
// A group of params can have a specific url
String url =
(String) patterns.get(
URL + String.valueOf(patternNumber));
url = controlUrl(url, defaultUrl);
htmlReader = getReader(url);
if ((start != null) && (stop == null))
{
element = new JetspeedClearElement(BAD_PARAM);
return element;
}
if (tagNum != null)
{
try
{
tagNumber = Integer.parseInt(tagNum);
}
catch (NumberFormatException e)
{
logger.info("Exception occurred:" + e.toString());
e.printStackTrace();
element = new JetspeedClearElement(BAD_NUMBER);
return element;
}
}
if ((simpleTag != null) && (tagNum == null))
clippedString =
clippedString
+ Transformer.findElement(
htmlReader,
url,
simpleTag);
else if ((simpleTag != null) && (tagNum != null))
clippedString =
clippedString
+ Transformer.findElementNumber(
htmlReader,
url,
simpleTag,
tagNumber);
else if (tagNum == null)
clippedString =
clippedString
+ Transformer.clipElements(
htmlReader,
url,
start,
stop);
else if (tagNum != null)
clippedString =
clippedString
+ Transformer.clipElementsNumber(
htmlReader,
url,
start,
stop,
tagNumber);
patternNumber = patternNumber + 1;
//Restart Enumeration, because params could not be in the right order
en = patterns.keys();
htmlReader.close();
}
}
element = new JetspeedClearElement(clippedString);
//FIXME: We should do a clearContent() for the media type, not ALL media types
this.clearContent();
// doing this because setContent() is not overwriting current content.
this.setContent(element);
}
catch (Exception e)
{
logger.info("Exception occurred:" + e.toString());
e.printStackTrace();
}
return element;
}
/**
* Usually called by caching system when portlet is marked as expired, but
* has not be idle longer then TimeToLive.
*
* Any cached content that is expired need to be refreshed.
*/
public void refresh()
{
if (cacheContent == true)
{
getWebClippedContent(null, this.getPortletConfig());
}
}
/**
* Select the URL to use for this portlet.
* @return The URL to use for this portlet
*/
protected String selectUrl(RunData data, PortletConfig config)
{
String url = config.getURL();
return url;
}
/*
* Choose between a specific url and the default url
*/
private String controlUrl(String url, String defaultUrl)
{
if (url == null)
{
return defaultUrl;
}
//if the given URL doesn not include a protocol... ie http:// or ftp://
//then resolve it relative to the current URL context
if (url.indexOf("://") < 0)
{
url = TurbineServlet.getResource(url).toString();
}
return url;
}
/*
* Load portlet parameters
*/
private void loadParams() throws PortletException
{
Iterator en = this.getPortletConfig().getInitParameterNames();
try
{
while (en.hasNext())
{
String name = (String) en.next();
if (name.equals("username"))
username =
this.getPortletConfig().getInitParameter("username");
else if (name.equals("password"))
password =
this.getPortletConfig().getInitParameter("password");
else
patterns.put(
name,
this.getPortletConfig().getInitParameter(name));
}
}
catch (Exception e)
{
logger.info("Exception occurred:" + e.toString());
e.printStackTrace();
throw new PortletException(e.toString());
}
}
}