public function doExecute()
{
$objPage = new Xerxes_Framework_Page();
$iTotalHits = (int) $this->request->getData("results/hits");
$strDatabaseTitle = (string) $this->request->getData("results/database");
$strSortKeys = (string) $this->request->getData("results/sort");
$iMax = $this->registry->getConfig("RECORDS_PER_PAGE", false, 10);
// create page hit summary element
$objSummaryXml = $objPage->summary($iTotalHits, (int) $this->request->getProperty("startRecord"), $iMax);
$this->request->addDocument($objSummaryXml);
// create sorting element only for merged results
if ($strDatabaseTitle == "Top Results") {
$arrParams = array("base" => "metasearch", "action" => "sort", "group" => $this->request->getProperty("group"));
$strQueryString = $this->request->url_for($arrParams);
$arrSortOptions = array("rank" => "relevance", "year" => "date", "title" => "title", "author" => "author");
if ($strSortKeys == null) {
$strSortKeys = $this->registry->getConfig("SORT_ORDER_PRIMARY", false, "rank");
}
$objSortXml = $objPage->sortDisplay($strQueryString, $strSortKeys, $arrSortOptions);
$this->request->addDocument($objSortXml);
}
// create paging element
$arrParams = array("base" => "metasearch", "action" => $this->request->getProperty("action"), "group" => $this->request->getProperty("group"), "resultSet" => $this->request->getProperty("resultSet"));
// only used in facets
if ($this->request->getProperty("node") != null) {
$arrParams["node"] = $this->request->getProperty("node");
$arrParams["facet"] = $this->request->getProperty("facet");
}
$objPagerXml = $objPage->pager_dom($arrParams, "startRecord", (int) $this->request->getProperty("startRecord"), null, (int) $iTotalHits, $iMax, $this->request);
$this->request->addDocument($objPagerXml);
return 1;
}
public function doExecute()
{
$objPage = new Xerxes_Framework_Page();
// get parameters and configuration information
$strUsername = $this->request->getSession("username");
$iStart = (int) $this->request->getProperty("startRecord");
$strLabel = $this->request->getProperty("label");
$strType = $this->request->getProperty("type");
$iMax = $this->registry->getConfig("SAVED_RECORDS_PER_PAGE", false, self::DEFAULT_RECORDS_PER_PAGE);
// get total number of saved records
$iTotal = $this->getTotal($strUsername, $strLabel, $strType);
### create page hit summary element
$objSummaryXml = $objPage->summary($iTotal, $iStart, $iMax);
$this->request->addDocument($objSummaryXml);
### create sorting element
$strSort = $this->request->getProperty("sortKeys");
if ($strSort == "") {
$strSort = "id";
}
$arrParams = array("base" => "folder", "action" => "home", "username" => $strUsername, "startRecord" => 1, "label" => $strLabel, "type" => $strType);
$strQueryString = $this->request->url_for($arrParams);
$arrSortOptions = array("title" => "title", "author" => "author", "year" => "date", "id" => "most recently added");
$objSortXml = $objPage->sortDisplay($strQueryString, $strSort, $arrSortOptions);
$this->request->addDocument($objSortXml);
### create paging element
$params = array("base" => "folder", "action" => "home", "username" => $this->request->getSession("username"), "sortKeys" => $this->request->getProperty("sortKeys"), "label" => $strLabel, "type" => $strType);
$objPagerXml = $objPage->pager_dom($params, "startRecord", (int) $this->request->getProperty("startRecord"), null, $iTotal, $iMax, $this->request);
$this->request->addDocument($objPagerXml);
return 1;
}
public static function execute()
{
// calculate current file, this directory
$this_directory = dirname(__FILE__);
// calculate root directory of the app ../../ from here
$path_to_parent = $this_directory;
$path_to_parent = str_replace("\\", "/", $path_to_parent);
$arrPath = explode("/", $path_to_parent);
array_pop($arrPath);
array_pop($arrPath);
$path_to_parent = implode("/", $arrPath);
// here so other framework files can reference it
self::$parent_directory = $path_to_parent;
// register framework any main xerxes class files
self::registerClasses("{$path_to_parent}/lib/framework", "Xerxes_Framework");
// initialize the configuration setting (Registry),
// command-view mapping (ControllerMap), and
// language translation (Languages) objects
$objRegistry = Xerxes_Framework_Registry::getInstance();
$objRegistry->init();
$objControllerMap = Xerxes_Framework_ControllerMap::getInstance();
$objControllerMap->init();
// set the version number, for interface or other places
$objRegistry->setConfig("XERXES_VERSION", $objControllerMap->getVersion(), true);
// dynamically set the web path, if config says so,
// doesn't work on all webserver/php set-ups, so an
// explicit web path from config is preferred
if ($objRegistry->getConfig("base_web_path", false) == '{dynamic}') {
if (isset($_SERVER)) {
$script_name = $_SERVER['SCRIPT_NAME'];
$script_name = str_replace("/index.php", "", $script_name);
$objRegistry->setConfig("base_web_path", $script_name);
}
}
// give our session a name to keep sessions distinct between multiple
// instances of xerxes on one server. use base_path (preferably) or
// application_name config directives.
$path_base = $objRegistry->getConfig("base_web_path", false);
$path_key = preg_replace('/\\W/', '_', $path_base);
$session_name = "xerxessession_" . $path_key;
if ($path_base == "") {
$path_base = "/";
}
$session_path = $objRegistry->getConfig("session_path", false, $path_base);
$session_domain = $objRegistry->getConfig("session_domain", false, null);
session_name($session_name);
session_set_cookie_params(0, $session_path, $session_domain);
session_start();
// processes the incoming request
$objRequest = Xerxes_Framework_Request::getInstance();
$objRequest->init();
// utility classes
// assists with basic paging/navigation elements for the view
$objPage = new Xerxes_Framework_Page($objRequest, $objRegistry);
// functions for special logging or handling of errors
$objError = new Xerxes_Framework_Error();
// language names
$objLanguage = Xerxes_Framework_Languages::getInstance();
$objLanguage->init();
// we'll put the remaining code in a try-catch block in order to show friendly error page
// for any uncaught exceptions
try {
####################
# DISPLAY ERRORS #
####################
if ($objRegistry->getConfig("DISPLAY_ERRORS") == true) {
error_reporting(E_ALL);
ini_set('display_errors', '1');
}
####################
# DEFAULTS #
####################
// labels
$objLabels = Xerxes_Framework_Labels::getInstance();
$lang = $objRequest->getProperty("lang");
$objLabels->init($lang);
// make sure application_name is passthrough, and has a value.
$objRegistry->setConfig("application_name", $objRegistry->getConfig("APPLICATION_NAME", false, "Xerxes", $lang), true);
####################
# SET PATHS #
####################
### reverse proxy
// check to see if xerxes is running behind a reverse proxy and swap
// host and remote ip here with their http_x_forwarded counterparts;
// but only if configured for this, since client can spoof the header
// if xerxes is not, in fact, behind a reverse proxy
if ($objRegistry->getConfig("REVERSE_PROXY", false, false) == true) {
$forward_host = $objRequest->getServer('HTTP_X_FORWARDED_HOST');
$forward_address = $objRequest->getServer('HTTP_X_FORWARDED_FOR');
if ($forward_host != "") {
$objRequest->setServer('SERVER_NAME', $forward_host);
}
// last ip address is the user's
if ($forward_address != "") {
$arrIP = explode(",", $forward_address);
$objRequest->setServer('REMOTE_ADDR', trim(array_pop($arrIP)));
}
}
// the working directory is the instance, so any relative paths will
// be executed in relation to the root directory of the instance
$working_dir = getcwd();
$working_dir = str_replace("\\", "/", $working_dir);
// full web path
//
// NOTE :if you change this code make sure you make a corresponding
// change in lib/framework/Error.php, since there is redundant code
// there in case something goes horribly wrong and we need to set the
// web path for proper display of a (friendly) error page
$base_path = $objRegistry->getConfig('BASE_WEB_PATH', false, "");
$this_server_name = $objRequest->getServer('SERVER_NAME');
// check for a non-standard port
$port = $objRequest->getServer('SERVER_PORT');
if ($port == 80 || $port == 443) {
$port = "";
} else {
$port = ":" . $port;
}
$protocol = "http://";
if ($objRequest->getServer("HTTPS")) {
$protocol = "https://";
}
$web = $protocol . $this_server_name . $port;
// register these values
$objRegistry->setConfig("SERVER_URL", $web);
$objRegistry->setConfig("PATH_PARENT_DIRECTORY", $path_to_parent);
$objRegistry->setConfig("APP_DIRECTORY", $working_dir);
$objRegistry->setConfig("BASE_URL", $web . $base_path, true);
####################
# INSTRUCTIONS #
####################
// ControllerMap contains instructions for commands and views
// based on the url parameters 'base' and 'action'
$strBase = $objRequest->getProperty("base");
$strAction = $objRequest->getProperty("action");
$objControllerMap->setAction($strBase, $strAction, $objRequest);
####################
# ACCESS CONTROL #
####################
// if this part of the application is restricted to a local ip range, or requires a named login, then the
// Restrict class will check the user's ip address or if they have logged in; failure stops the flow
// and redirects user to a login page with the current request passed as 'return' paramater in the url
$objRestrict = new Xerxes_Framework_Restrict($objRequest);
// command line scripts will ignore access rules
if ($objRequest->isCommandLine() != true) {
if ($objControllerMap->isRestricted() == true) {
if ($objControllerMap->requiresLogin() == true) {
// resource requires a valid named username
$objRestrict->checkLogin();
} else {
// resource is resricted, but local ip range is okay
$objRestrict->checkIP();
}
} else {
// go ahead and register local users, but don't prompt for login
$objRestrict->checkIP(false);
}
}
// if this action is set to only be run via the command line, in order to prevent
// web execution of potentially long-running tasks, then restrict it here
if (!$objRequest->isCommandLine() && $objControllerMap->restrictToCLI()) {
throw new Exception("cannot run command from web");
}
####################
# INCLUDES #
####################
// files and directories that have been set to be included by the config file
foreach ($objControllerMap->getIncludes() as $path_to_include) {
self::registerClasses($path_to_parent . "/{$path_to_include}");
}
####################
# DATA #
####################
// set-up the data by defining the root element
$strDocumentElement = $objControllerMap->getDocumentElement();
$objRequest->setDocumentElement($strDocumentElement);
// pass config values that should be made available to the XSLT
$objRequest->addDocument($objRegistry->publicXML());
// the data will be built-up by calling one or more command classes
// which will fetch their data based on other parameters supplied in
// the request; returning that data as xml to a master xml dom document
// inside the Xerxes_Framework_Request class, or in some cases specififying
// a url to redirect the user out
$commands = $objControllerMap->getCommands();
foreach ($commands as $arrCommand) {
$strDirectory = $arrCommand[0];
// directory where the command class is located
$strNamespace = $arrCommand[1];
// prefix namespace of the command class
$strClassFile = $arrCommand[2];
// suffix name of the command class
// directory where commands live
$command_path = "{$path_to_parent}/commands/{$strDirectory}";
// allow for a local override, even
$local_command_path = "commands/{$strDirectory}";
// echo "<h3>$strClassFile</h3>";
// first, include any parent class, assuming that the parent class will
// follow the naming convention of having the same name as the directory
$strParentClass = Xerxes_Framework_Parser::strtoupper(substr($strDirectory, 0, 1)) . substr($strDirectory, 1);
if (file_exists("{$local_command_path}/{$strParentClass}.php")) {
require_once "{$local_command_path}/{$strParentClass}.php";
} elseif (file_exists("{$command_path}/{$strParentClass}.php")) {
require_once "{$command_path}/{$strParentClass}.php";
}
// if the specified command class exists in the distro or local commands folder, then
// instantiate an object and execute it
$strClass = $strNamespace . "_Command_" . $strClassFile;
$local_command = file_exists("{$local_command_path}/{$strClassFile}.php");
if (file_exists("{$command_path}/{$strClassFile}.php") || $local_command) {
// if the instance has a local version, take it!
if ($local_command) {
require_once "{$local_command_path}/{$strClassFile}.php";
} else {
require_once "{$command_path}/{$strClassFile}.php";
}
// instantiate the command class and execute it, but only
// if it extends xerxes_framework_command
$objCommand = new $strClass();
if ($objCommand instanceof Xerxes_Framework_Command) {
$objCommand->execute($objRequest, $objRegistry);
} else {
throw new Exception("command classes must be instance of Xerxes_Framework_Command");
}
} else {
// if no command but a view was specified, then go ahead and show the view
// minus any data, since the view is doin' its own thang
if (!file_exists($objControllerMap->getView())) {
throw new Exception("invalid command {$strClass}");
}
}
}
####################
# COOKIES #
####################
// any cookies specified in the reuqest object? if so, set em now.
$cookieSetParams = $objRequest->cookieSetParams();
foreach ($cookieSetParams as $cookieParams) {
set_cookie($cookieParams[0], $cookieParams[1], $cookieParams[2], $cookieParams[3], $cookieParams[4], $cookieParams[5]);
}
####################
# REDIRECT #
####################
// if the result of the command is a redirect, we will stop the
// flow and redirect the user out, unless overridden by the noRedirect
// directive
if ($objRequest->getRedirect() != null) {
if ($objRequest->getProperty("noRedirect") == null) {
header("Location: " . $objRequest->getRedirect());
exit;
} else {
// include in the resposne what the redirect would have been
$objRequest->setProperty("redirect", $objRequest->getRedirect());
}
}
####################
# VIEW #
####################
// SET THE HTTP HEADER
//
// we'll set the content-type, and potentially other header elements, based on the paramater 'format';
// format must correspond to one of the pre-defined format content-types in setHeader() or can be a user-
// defined format set in action.xml
$format = $objRequest->getProperty("format");
if ($objControllerMap->getFormat($format) != null) {
header($objControllerMap->getFormat($format));
} else {
self::setHeader($format);
}
// get the xml from the request object, but exclude any server information
// from being included if format=source
$bolShowServer = true;
if ($format == "xerxes") {
$bolShowServer = false;
}
$objXml = new DOMDocument();
$objXml = $objRequest->toXML($bolShowServer);
// RAW XML DISPLAY
//
// you can append 'format=xerxes' to the querystring to have this controller spit back
// the response in plain xml, which can be useful in some cases, like maybe AJAX?
if ($format == "xerxes") {
echo $objXml->saveXML();
} else {
// VIEW CODE
//
// ControllerMap contains instructions on what file to include for the view; typically
// this will be an xslt file, but could be a php file if the xslt does not
// provide enough flexibility; php page will inherit the xml dom document and
// can go from there
if ($objControllerMap->getView() == "") {
// No view specified, no view will be executed.
return;
}
// PHP CODE
if ($objControllerMap->getViewType() != "xsl" && $objControllerMap->getViewType() != null) {
$file = $objControllerMap->getView();
$distro_file = $objRegistry->getConfig("PATH_PARENT_DIRECTORY", true) . "/lib/{$file}";
if (file_exists($file)) {
require_once $file;
} elseif (file_exists($distro_file)) {
require_once $distro_file;
} else {
throw new Exception("Could not find non-xsl view specified to include: {$file}");
}
} else {
// XSLT CODE
$output = $objPage->transform($objXml, $objControllerMap->getView(), null);
// EMBEDED JAVASCRIPT DISPLAY
//
// you can append 'format=embed_html_js' to the querystring to output
// the content as a javascript source document with everything wrapped in
// document.write() statements
if ($format == "embed_html_js") {
// first escape any single quotes
$output = str_replace("'", "\\'", $output);
// now break the html into lines and output with document.write('')
$lines = explode("\n", $output);
$new_lines = array("// Javascript output. ");
foreach ($lines as $line) {
array_push($new_lines, "document.write('" . $line . "');");
}
$output = implode("\n", $new_lines);
}
echo $output;
}
//remove the flash message, intended for one display only.
$objRequest->setSession("flash_message", null);
}
} catch (Exception $e) {
$objError->handle($e, $objRequest, $objRegistry);
}
}
/**
* Take search results and convert them to xml, with all the enhancements, including facets
*/
public function resultsXML()
{
$this->url = $this->search_object->getURL();
// get total and set in session
if ($this->total == null) {
$this->total = $this->search_object->getTotal();
}
$id = $this->getHashID() . "-" . $this->getHash();
$this->request->setSession($id, number_format($this->total));
$results_xml = new DOMDocument();
$results_xml->loadXML("<results />");
// other cached search hits?
foreach ($this->request->getAllSession() as $session_id => $session_value) {
if (strstr($session_id, $this->query_hash)) {
$id = str_replace("-" . $this->query_hash, "", $session_id);
$other = $results_xml->createElement("other", $session_value);
$other->setAttribute("module", $id);
$results_xml->documentElement->appendChild($other);
}
}
// spelling
$spelling_url = $this->linkSpelling();
$spelling = $results_xml->createElement("spelling", Xerxes_Framework_Parser::escapeXml($this->request->getProperty("spelling_query")));
$spelling->setAttribute("url", $spelling_url);
$results_xml->documentElement->appendChild($spelling);
// add in the original url for debugging
$search_url = $results_xml->createElement("search_url", Xerxes_Framework_Parser::escapeXml($this->url));
$results_xml->documentElement->appendChild($search_url);
// add total
$total = $results_xml->createElement("total", number_format($this->total));
$results_xml->documentElement->appendChild($total);
// add facets that have been selected
$facets_chosen = $this->request->getProperties("facet.*", true);
if (count($facets_chosen) > 0) {
$facet_applied = $results_xml->createElement("facets_applied");
$results_xml->documentElement->appendChild($facet_applied);
foreach ($facets_chosen as $key => $facet) {
$facet_level = $results_xml->createElement("facet_level", Xerxes_Framework_Parser::escapeXml($facet));
$facet_applied->appendChild($facet_level);
$url = new Xerxes_Framework_Request_URL($this->currentParams());
$url->removeProperty($key, $facet);
$remove_url = $this->request->url_for($url);
$facet_level->setAttribute("url", $remove_url);
}
}
if (count($this->results) > 0) {
## records
$records_xml = $results_xml->createElement("records");
$results_xml->documentElement->appendChild($records_xml);
foreach ($this->results as $result) {
$record_container = $results_xml->createElement("record");
$records_xml->appendChild($record_container);
// full-record link
$record_link = Xerxes_Framework_Parser::escapeXml($this->linkFullRecord($result));
$link_full = $results_xml->createElement("url", $record_link);
$record_container->appendChild($link_full);
// this one for backwards compatibility
$link_full = $results_xml->createElement("url_full", $record_link);
$record_container->appendChild($link_full);
// open-url link (which may be a redirect)
$record_openurl = Xerxes_Framework_Parser::escapeXml($this->linkOpenURL($result));
$link_full = $results_xml->createElement("url_open", $record_openurl);
$record_container->appendChild($link_full);
// sms link
$record_sms = Xerxes_Framework_Parser::escapeXml($this->linkSMS($result));
$link_sms = $results_xml->createElement("url_sms", $record_sms);
$record_container->appendChild($link_sms);
// save or delete link
$record_save = Xerxes_Framework_Parser::escapeXml($this->linkSaveRecord($result));
$link_save = $results_xml->createElement("url_save", $record_save);
$record_container->appendChild($link_save);
// this one for backwards compatibility
$link_save = $results_xml->createElement("url_save_delete", $record_save);
$record_container->appendChild($link_save);
// openurl kev context object please
$kev = Xerxes_Framework_Parser::escapeXml($result->getOpenURL(null, $this->sid));
$open_url = $results_xml->createElement("openurl_kev_co", $kev);
$record_container->appendChild($open_url);
// other links (probably things like author, subject links)
$this->linkOther($result, $results_xml, $record_container);
// xerxes-record
$xerxes_xml = $result->toXML();
$import = $results_xml->importNode($xerxes_xml->documentElement, true);
$record_container->appendChild($import);
// optionally import original xml
if ($this->include_original == true) {
$original_xml = $result->getOriginalXML();
$original_node = $original_xml;
if ($original_xml instanceof DOMDocument) {
$original_node = $original_xml->documentElement;
}
$import = $results_xml->importNode($original_node, true);
$record_container->appendChild($import);
}
}
## recommendations
if (count($this->recommendations) > 0) {
$recommend_xml = $results_xml->createElement("recommendations");
$results_xml->documentElement->appendChild($recommend_xml);
foreach ($this->recommendations as $record) {
$record_xml = $results_xml->createElement("record");
$recommend_xml->appendChild($record_xml);
$import = $results_xml->importNode($record->toXML()->documentElement, true);
$record_xml->appendChild($import);
$open_url = $record->getOpenURL($this->link_resolver, $this->sid);
$open_url_xml = $results_xml->createElement("url_open", Xerxes_Framework_Parser::escapeXML($open_url));
$record_xml->appendChild($open_url_xml);
}
}
$objPage = new Xerxes_Framework_Page();
## summary
$summary_xml = $objPage->summary($this->total, (int) $this->request->getProperty("startRecord"), $this->max);
if ($summary_xml->documentElement != null) {
$import = $results_xml->importNode($summary_xml->documentElement, true);
$results_xml->documentElement->appendChild($import);
}
## sorting
$arrParams = $this->sortLinkParams();
$query_string = $this->request->url_for($arrParams);
$sort_options = $this->sortOptions();
$current_sort = $this->sort;
if ($current_sort == null) {
$current_sort = $this->sort_default;
}
$sort_xml = $objPage->sortDisplay($query_string, $current_sort, $sort_options);
$import = $results_xml->importNode($sort_xml->documentElement, true);
$results_xml->documentElement->appendChild($import);
## pager
$arrParams = $this->pagerLinkParams();
$pager_xml = $objPage->pager_dom($arrParams, "startRecord", (int) $this->request->getProperty("startRecord"), null, (int) $this->total, $this->max, $this->request);
$import = $results_xml->importNode($pager_xml->documentElement, true);
$results_xml->documentElement->appendChild($import);
}
## facets
$facets = $this->facets->toXML();
$import = $results_xml->importNode($facets->documentElement, true);
$results_xml->documentElement->appendChild($import);
return $results_xml;
}
