'),
'#description' => t('The list of tags which are allowed in feeds, i.e., which will not be removed by Drupal.')
);
$form['feedapi_allow_html_all'] = array(
'#type' => 'checkbox', '#title' => t('Allow all HTML tags'),
'#default_value' => variable_get('feedapi_allow_html_all', FALSE),
'#description' => t('In this case the module does\'t filter any HTML elements from the incoming fields. This checkbox overrides the above list of allowed tags.')
);
$form['feedapi_show_feed_origin_link'] = array(
'#type' => 'checkbox', '#title' => t('Show originating site link with feed nodes.'),
'#default_value' => variable_get('feedapi_show_feed_origin_link', TRUE),
);
if (variable_get('feedapi_allow_html_all', FALSE)) {
$form['feedapi_allowed_html_tags']['#disabled'] = TRUE;
}
$form['feedapi_statistics_queue'] = array(
'#type' => 'select',
'#title' => t('Number of samples stored per feed for statistics'),
'#options' => drupal_map_assoc(array(10, 20, 50, 100)),
'#default_value' => variable_get('feedapi_statistics_queue', 10),
);
// Drupal will try to overwrite this value at cron time
$max_exec = !ini_get('safe_mode') ? 240 : ini_get('max_execution_time');
$form['feedapi_cron_percentage'] = array(
'#type' => 'select',
'#title' => t('Cron time for FeedAPI [%]'),
'#options' => drupal_map_assoc(array(15, 25, 50, 75)),
'#default_value' => variable_get('feedapi_cron_percentage', 15),
'#description' => t('Percentage of maximal PHP execution time (currently !exec seconds).
At current settings, the FeedAPI cron process can run for up to !now seconds.',
array("!exec" => $max_exec, "!now" => (variable_get('feedapi_cron_percentage', 15) / 100) * $max_exec)),
);
return system_settings_form($form);
}
/**
* Create a feedapi node programatically.
* @param $param
* Either a feedapi - enabled node type or a $node object with at least valid $node->type.
* @param $url
* URI of feed.
*/
function feedapi_create_node($param, $url) {
if (is_object($param)) {
$node = $param;
}
else {
$node = new stdClass();
$node->type = $param;
}
if (!feedapi_enabled($node->type)) {
return FALSE;
}
$feed = _feedapi_build_feed_object($node->type, $url);
if (!$feed->title && !$node->title) {
return FALSE;
}
$node->title = $node->title ? $node->title : $feed->title;
$node->body = $node->body ? $node->body : $feed->description;
$node->feed = $feed;
$node_options = variable_get('node_options_'. $node->type, array('status', 'promote'));
// If this is a new node, fill in the default values.
foreach (array('status', 'promote', 'sticky') as $key) {
$node->$key = in_array($key, $node_options);
}
// Get the content-type settings as default
$node->feedapi = _feedapi_get_settings(array('node_type' => $node->type));
node_object_prepare($node);
global $user;
$node->uid = $user->uid;
node_save($node);
return $node;
}
/**
* Load node by URL.
* @param $args
* Currently only supported $args['url] - URL string.
* @return
* Node object if successful, FALSE if not.
*/
function feedapi_load_node($args) {
if ($nid = db_result(db_query('SELECT nid FROM {feedapi} WHERE url = "%s"', $args['url']))) {
return node_load($nid);
}
return FALSE;
}
/**
* Refresh a feed node (= run enabled processors on it).
* @param $node
* A node object with a $node->feed object.
* @param $destination_path
* If a destination path is given, function redirects to this destination.
*/
function feedapi_refresh($node, $destination_path = NULL) {
feedapi_invoke_feedapi('refresh', $node->feed, $cron);
if ($destination_path) {
drupal_goto($destination_path);
}
}
/**
* Insert feedapi data to the DB when it's a new for for FeedAPI
*/
function _feedapi_insert(&$node, $teaser, $page) {
if (isset($node->feed->url) && isset($node->feed->feed_type)) {
db_query("INSERT INTO {feedapi} (
nid, url, link, feed_type, processors,
parsers, checked, settings) VALUES
(%d, '%s', '%s', '%s', '%s', '%s', %d, '%s')",
$node->nid,
$node->feed->url,
$node->feed->options->link,
$node->feed->feed_type,
serialize($node->feed->processors),
serialize($node->feed->parsers),
0,
serialize(array())
);
// Store add on module's settings if user has permission to do so.
if (user_access('advanced feedapi options')) {
_feedapi_store_settings(array('nid' => $node->nid), $node->feedapi);
}
// Refresh feed if the user would like to do that
if ($node->feedapi['refresh_on_create'] == TRUE) {
$node->feed->nid = $node->nid;
feedapi_invoke_feedapi('refresh', $node->feed);
}
}
}
/**
* Update feed data of an existing feed
*/
function _feedapi_update(&$node, $teaser, $page) {
if (isset($node->feed)) {
$old_config = node_load($node->nid);
// In that case this feed has never have feed data. Should be created then, this is not really an update
if (!is_numeric($old_config->feed->nid)) {
$node->feed = _feedapi_build_feed_object($node->type, $node->feed->url);
_feedapi_insert($node, 'insert', $teaser, $page);
return;
}
foreach ($old_config->feed->processors as $processor) {
if (!in_array($processor, $node->feed->processors)) {
$items = module_invoke($processor, 'feedapi_item', 'fetch', $node->feed);
foreach ($items as $item) {
module_invoke($processor, 'feedapi_item', 'delete', $item);
}
}
}
db_query("UPDATE {feedapi} SET
url = '%s', feed_type = '%s', processors = '%s',
parsers = '%s', link = '%s' WHERE nid = %d",
$node->feed->url,
$node->feed->feed_type,
serialize($node->feed->processors),
serialize($node->feed->parsers),
$node->feed->options->link,
$node->nid
);
// Store add on module's settings if user has permission to do so.
if (user_access('advanced feedapi options')) {
_feedapi_store_settings(array('nid' => $node->nid), $node->feedapi);
}
}
}
/**
* Execute the enabled parsers and create an unified output
*
* @param $feed
* Feed object
* @param $cache
* Parser result is cacheable or not
* @param $parsers
* Structure: array(
* "primary" => "parser_primary",
* "secondary" => array("parser1", "parser2", "parserN")
* );
* @return
* The object of the parser data
*/
function _feedapi_call_parsers($feed, $parsers, $cache) {
$nid = $feed->nid;
$parser_primary = array_shift($parsers);
$parsers_secondary = $parsers;
if (module_exists($parser_primary)) {
$feed->feed_type = module_invoke($parser_primary, 'feedapi_feed', 'compatible', $feed);
$parser_output = module_invoke($parser_primary, 'feedapi_feed', 'parse', $feed, $cache);
if ($parser_output === FALSE && $cache) {
return $parser_output;
}
$feed = (object) array_merge((array) $feed, (array) $parser_output);
}
// Call the turned on parsers, create a union of returned options
$parsers_secondary = is_array($parsers_secondary) ? $parsers_secondary : array();
foreach ($parsers_secondary as $parser) {
$feed_ext = module_invoke($parser, 'feedapi_feed', 'parse', $feed, FALSE);
$feed->options = (object) ((array) $feed->options + (array) $feed_ext->options);
// Merge items' options
foreach ($feed_ext->items as $key => $item) {
$feed->items[$key]->options = (object) ((array) $feed->items[$key]->options + (array) $item->options);
}
}
$feed->nid = $nid;
foreach (module_implements('feedapi_after_parse') as $module) {
$func = $module. '_feedapi_after_parse';
$func($feed);
}
// Filter bad or not allowed tags, sanitize data (currently timestamp checking)
if (!variable_get('feedapi_allow_html_all', FALSE)) {
$allowed = preg_split('/\s+|<|>/', variable_get('feedapi_allowed_html_tags', '
'), -1, PREG_SPLIT_NO_EMPTY);
foreach (array('title', 'description') as $property) {
if (isset($feed->{$property})) {
if (is_string($feed->{$property})) {
$feed->{$property} = filter_xss($feed->{$property}, $allowed);
}
}
}
for ($i = 0; $i < count($feed->items); $i++) {
$feed->items[$i]->title = filter_xss($feed->items[$i]->title, $allowed);
$feed->items[$i]->description = filter_xss($feed->items[$i]->description, $allowed);
if ($feed->items[$i]->options->timestamp == 0) {
$feed->items[$i]->options->timestamp = time();
}
}
}
return $feed;
}
/**
* Stores settings per content type or per node.
*
* @param $args
* Associative array which is $args['nid'] = N or $args['node_type'] = "content_type". Depends on what to store for
* @param $settings
* The settings data itself
*/
function _feedapi_store_settings($args, $settings) {
if ($args['nid']) {
db_query("UPDATE {feedapi} SET settings = '%s' WHERE nid = %d", serialize($settings), $args['nid']);
module_invoke_all('feedapi_after_settings', $args['nid'], $settings);
}
elseif ($args['node_type']) {
variable_set('feedapi_settings_'. $args['node_type'], $settings);
}
}
/**
* Determines wether feedapi is enabled for given node type.
* If parser or processor is passed in, this function determines wether given
* parser or processor is enabled for given node type.
* @param $node_type
* A Drupal node type.
* @param $parser_or_processor
* A parser or processor - pass in by module name.
* @return TRUE if enabled, FALSE if not.
*/
function feedapi_enabled($node_type, $parser_or_processor = '') {
$settings = _feedapi_get_settings(array('node_type' => $node_type));
if (!$parser_or_processor || !$settings['enabled']) {
return $settings['enabled'] ? TRUE : FALSE;
}
foreach (array('parsers', 'processors') as $stage) {
if ($settings[$stage][$parser_or_processor]['enabled']) {
return TRUE;
}
}
return FALSE;
}
/**
* Helper function for feedapi_invoke().
* Load a list of feed items into the feed object from the processors.
*/
function _feedapi_invoke_load(&$feed, $param) {
$feed->items = array();
foreach ($feed->processors as $processor) {
$items = module_invoke($processor, 'feedapi_item', 'fetch', $feed);
if (is_array($items)) {
foreach ($items as $item) {
$feed->items[] = $item;
}
}
}
}
/**
* Helper function for feedapi_invoke().
* Refresh the feed, call the proper parsers and processors' hooks.
* Don't call this function directly, use feedapi_refresh() instead.
*/
function _feedapi_invoke_refresh(&$feed, $param) {
timer_start('feedapi_'. $feed->nid);
$cron = $param;
if (!is_array($feed->processors) || count($feed->processors) == 0) {
if (!$cron) {
drupal_set_message(t("No processors specified for URL %url. Could not refresh.", array('%url' => $feed->url)), "error");
drupal_goto('node/'. $feed->nid);
}
return;
}
// Force the processors to delete old items and determine the max. create elements
$refresh = feedapi_expire($feed, $cron === TRUE ? FALSE : TRUE);
if ($refresh == FALSE) {
return;
}
$nid = $feed->nid;
// Force non-caching mode if the feed is only processed half-done.
$feed = _feedapi_call_parsers($feed, $feed->parsers, $feed->half_done ? FALSE : TRUE);
if (($feed === FALSE) || (!is_array($feed->items))) {
// Refresh the Last refresh field at all the cases
db_query("UPDATE {feedapi} SET checked = %d, half_done = %d WHERE nid = %d", time(), FALSE, $nid);
if (!$cron) {
drupal_set_message(t('Could not refresh feed.'));
}
return;
}
$items = array_reverse($feed->items);
$updated = 0;
$new = 0;
$half_done = FALSE;
$settings = _feedapi_get_settings(array('nid' => $feed->nid));
// Walk through the items
foreach ($items as $item) {
// Call each item parser
$is_updated = FALSE;
$is_new = FALSE;
foreach ($feed->processors as $processor) {
if (!module_invoke($processor, 'feedapi_item', 'unique', $item, $feed->nid, $feed->settings['processors'][$processor])) {
if ($settings['update_existing'] == TRUE) {
module_invoke($processor, 'feedapi_item', 'update', $item, $feed->nid, $feed->settings['processors'][$processor]);
$is_updated = TRUE;
}
}
else {
// if the item is already expired then do nothing
$diff = abs(time() - (isset($item->options->timestamp) ? $item->options->timestamp : time()));
$items_delete = $settings['items_delete'];
if ($diff > $items_delete && ($items_delete > FEEDAPI_NEVER_DELETE_OLD)) {
break;
}
module_invoke($processor, 'feedapi_item', 'save', $item, $feed->nid, $feed->settings['processors'][$processor]);
$is_new = TRUE;
}
}
$new = $is_new ? $new + 1 : $new;
$updated = ($is_updated && !$is_new) ? $updated + 1 : $updated;
// decision on time. If the exec time is greather than the user-set percentage of php max execution time
if ($cron && ((timer_read('feedapi_cron') / 1000) > ((variable_get('feedapi_cron_percentage', 15) / 100) * ini_get('max_execution_time')))) {
$timeout = FEEDAPI_TIMEOUT;
$half_done = ($new + $updated) == count($items) ? FALSE : TRUE;
break;
}
}
foreach (module_implements('feedapi_after_refresh') as $module) {
$func = $module. '_feedapi_after_refresh';
$func($feed);
}
if ($new > 0) {
$feed->statistics['update_times'] = _feedapi_queue($feed->statistics['update_times'], time());
$feed->statistics['new'] = _feedapi_queue($feed->statistics['new'], $new);
$feed->statistics['download_num'] = _feedapi_queue($feed->statistics['download_num'], count($items));
$feed->statistics['process_time'] = _feedapi_queue($feed->statistics['process_time'], timer_read('feedapi_'. $feed->nid));
}
db_query("UPDATE {feedapi} SET checked = %d, statistics = '%s', half_done = %d WHERE nid = %d", time(), serialize($feed->statistics), $half_done, $feed->nid);
if (!$cron) {
drupal_set_message(t("%new new item(s) were saved. %updated existing item(s) were updated.", array("%new" => $new, "%updated" => $updated)));
}
if ($timeout) {
return $timeout;
}
}
/**
* Helper function for feedapi_invoke().
* Delete all feed items of a feed.
*/
function _feedapi_invoke_purge(&$feed, $param) {
$node = node_load($feed->nid);
if ($param == 'items') {
return drupal_get_form('feedapi_purge_confirm', $node);
}
feedapi_invoke_feedapi('load', $feed);
// Delete items from the processors
foreach ($feed->items as $item) {
foreach($feed->processors as $processor) {
// FIXME: it's possible now to accidentally delete an item from another processor
module_invoke($processor, 'feedapi_item', 'delete', $item, $feed->settings['processors'][$processor]);
}
}
if ($param == 'items_confirmed') {
drupal_set_message(t('!count feed items have been deleted successfully from the feed.', array('!count' => count($feed->items))));
}
}
/**
* Builds feed object ready to be sticked onto node.
*/
function _feedapi_build_feed_object($node_type, $url) {
$feed = new stdClass();
$feed->url = $url;
$node_type_settings = _feedapi_get_settings(array('node_type' => $node_type));
$feed->processors = _feedapi_format_settings($node_type_settings, 'processors');
$feed->parsers = _feedapi_format_settings($node_type_settings, 'parsers');
if ($feed->url) {
$feed = _feedapi_call_parsers($feed, $feed->parsers, FALSE);
}
$feed->link = $feed->options->link;
return $feed;
}
/**
* Returns per content type settings ordered by weight
* and only those that are turned on.
* @param $node_type_settings
* Content type settings retrieved with _feedapi_get_settings().
* @param $stage_type
* 'parsers' or 'processors'
*/
function _feedapi_format_settings($node_type_settings, $stage_type) {
$result = array();
$settings = $node_type_settings[$stage_type];
foreach ($settings as $name => $properties) {
if ($settings[$name]['enabled']) {
$result[$settings[$name]['weight']] = $name;
}
}
ksort($result);
return $result;
}
/**
* Retrieve settings per content type or per node.
* @param $args
* Array in the format of:
* $args = array(
* 'node_type' => '