PluginProbe
FeedWordPress / 2017.1004
FeedWordPress v2017.1004
trunk 0.8 0.9 0.91 0.95 0.96 0.97 0.98 0.981 0.99 0.991 0.992 0.993 2008.1030 2008.1101 2008.1105 2008.1214 2009.0612 2009.0613 2009.0618 2009.0707 2009.1111 2009.1112 2010.0127 2010.0528 All 65 releases
← All changes | feedwordpress.php +1963 -684 2009.1111 → 2017.1004 View file →
@@ -2,36 +2,45 @@
2 2 /*
3 3 Plugin Name: FeedWordPress
4 4 Plugin URI: http://feedwordpress.radgeek.com/
5 5 Description: simple and flexible Atom/RSS syndication for WordPress
6 -Version: 2009.1111
6 +Version: 2017.1004
7 7 Author: Charles Johnson
8 8 Author URI: http://radgeek.com/
9 9 License: GPL
10 10 */
11 11
12 +/**
13 + * @package FeedWordPress
14 + * @version 2017.1004
15 + */
16 +
12 17 # This uses code derived from:
13 18 # - wp-rss-aggregate.php by Kellan Elliot-McCrea <kellan@protest.net>
14 -# - HTTP Navigator 2 by Keyvan Minoukadeh <keyvan@k1m.com>
19 +# - SimplePie feed parser by Ryan Parman, Geoffrey Sneddon, Ryan McCue, et al.
20 +# - MagpieRSS feed parser by Kellan Elliot-McCrea <kellan@protest.net>
15 21 # - Ultra-Liberal Feed Finder by Mark Pilgrim <mark@diveintomark.org>
22 +# - WordPress Blog Tool and Publishing Platform <http://wordpress.org/>
16 23 # according to the terms of the GNU General Public License.
17 24 #
18 -# INSTALLATION: see readme.txt or <http://projects.radgeek.com/install>
25 +# INSTALLATION: see readme.txt or <http://feedwordpress.radgeek.com/install>
19 26 #
20 27 # USAGE: once FeedWordPress is installed, you manage just about everything from
21 -# the WordPress Dashboard, under the Syndication menu. To ensure that fresh
22 -# content is added as it becomes available, you can convince your contributors
23 -# to put your XML-RPC URI (if WordPress is installed at
24 -# <http://www.zyx.com/blog>, XML-RPC requests should be sent to
25 -# <http://www.zyx.com/blog/xmlrpc.php>), or update manually under the
26 -# Syndication menu, or set up automatic updates under Syndication --> Settings,
27 -# or use a cron job.
28 +# the WordPress Dashboard, under the Syndication menu. To keep fresh content
29 +# coming in as it becomes available, you'll have to either check for updates
30 +# manually, or set up one of the automatically-scheduled update methods. See
31 +# <http://feedwordpress.radgeek.com/wiki/quick-start/> for some details.
28 32
29 33 # -- Don't change these unless you know what you're doing...
30 34
31 -define ('FEEDWORDPRESS_VERSION', '2009.0803');
35 +define ('FEEDWORDPRESS_VERSION', '2017.1004');
32 36 define ('FEEDWORDPRESS_AUTHOR_CONTACT', 'http://radgeek.com/contact');
33 37
38 +if (!defined('FEEDWORDPRESS_BLEG')) :
39 + define ('FEEDWORDPRESS_BLEG', true);
40 +endif;
41 +define('FEEDWORDPRESS_BLEG_BTC', '1FN3Q4VSR4jV7unRjaknVQVe5ky88ktPHS');
42 +
34 43 // Defaults
35 44 define ('DEFAULT_SYNDICATION_CATEGORY', 'Contributors');
36 45 define ('DEFAULT_UPDATE_PERIOD', 60); // value in minutes
37 46
@@ -43,8 +52,10 @@
43 52 $feedwordpress_debug = ($feedwordpress_debug == 'yes');
44 53 endif;
45 54 endif;
46 55 define ('FEEDWORDPRESS_DEBUG', $feedwordpress_debug);
56 +$feedwordpress_compatibility = true;
57 +define ('FEEDWORDPRESS_COMPATIBILITY', $feedwordpress_compatibility);
47 58
48 59 define ('FEEDWORDPRESS_CAT_SEPARATOR_PATTERN', '/[:\n]/');
49 60 define ('FEEDWORDPRESS_CAT_SEPARATOR', "\n");
50 61
@@ -52,67 +63,98 @@
52 63
53 64 define ('FEEDWORDPRESS_FRESHNESS_INTERVAL', 10*60); // Every ten minutes
54 65
55 66 define ('FWP_SCHEMA_HAS_USERMETA', 2966);
56 -define ('FWP_SCHEMA_20', 3308); // Database schema # for WP 2.0
57 -define ('FWP_SCHEMA_21', 4772); // Database schema # for WP 2.1
58 -define ('FWP_SCHEMA_23', 5495); // Database schema # for WP 2.3
59 -define ('FWP_SCHEMA_25', 7558); // Database schema # for WP 2.5
60 -define ('FWP_SCHEMA_26', 8201); // Database schema # for WP 2.6
61 -define ('FWP_SCHEMA_27', 9872); // Database schema # for WP 2.7
62 -define ('FWP_SCHEMA_28', 11548); // Database schema # for WP 2.8
67 +define ('FWP_SCHEMA_USES_ARGS_TAXONOMY', 12694); // Revision # for using $args['taxonomy'] to get link categories
68 +define ('FWP_SCHEMA_30', 12694); // Database schema # for WP 3.0
63 69
64 70 if (FEEDWORDPRESS_DEBUG) :
65 71 // Help us to pick out errors, if any.
66 72 ini_set('error_reporting', E_ALL & ~E_NOTICE);
67 73 ini_set('display_errors', true);
68 - define('MAGPIE_DEBUG', true);
69 -
74 +
70 75 // When testing we don't want cache issues to interfere. But this is
71 - // a VERY BAD SETTING for a production server. Webmasters will eat your
76 + // a VERY BAD SETTING for a production server. Webmasters will eat your
72 77 // face for breakfast if you use it, and the baby Jesus will cry. So
73 78 // make sure FEEDWORDPRESS_DEBUG is FALSE for any site that will be
74 79 // used for more than testing purposes!
75 - define('MAGPIE_CACHE_AGE', 1);
80 + define('FEEDWORDPRESS_CACHE_AGE', 1);
81 + define('FEEDWORDPRESS_CACHE_LIFETIME', 1);
82 + define('FEEDWORDPRESS_FETCH_TIMEOUT_DEFAULT', 60);
76 83 else :
77 - define('MAGPIE_DEBUG', false);
78 -
79 - define('MAGPIE_CACHE_AGE', 1*60);
84 + // Hold onto data all day for conditional GET purposes,
85 + // but consider it stale after 1 min (requiring a conditional GET)
86 + define('FEEDWORDPRESS_CACHE_LIFETIME', 24*60*60);
87 + define('FEEDWORDPRESS_CACHE_AGE', 1*60);
88 + define('FEEDWORDPRESS_FETCH_TIMEOUT_DEFAULT', 20);
80 89 endif;
81 90
82 -// Note that the rss-functions.php that comes prepackaged with WordPress is
83 -// old & busted. For the new hotness, drop a copy of rss.php from
84 -// this archive into wp-includes/rss.php
91 +// Use our the cache settings that we want.
92 +add_filter('wp_feed_cache_transient_lifetime', array('FeedWordPress', 'cache_lifetime'));
85 93
86 -if (is_readable(ABSPATH . WPINC . '/rss.php')) :
87 - require_once (ABSPATH . WPINC . '/rss.php');
88 -else :
89 - require_once (ABSPATH . WPINC . '/rss-functions.php');
90 -endif;
94 +// Dependencies: modules packaged with WordPress core
95 +$wpCoreDependencies = array(
96 +"class:SimplePie" => "class-simplepie",
97 +"class:WP_Feed_Cache" => "class-wp-feed-cache",
98 +"class:WP_Feed_Cache_Transient" => "class-wp-feed-cache-transient",
99 +"class:WP_SimplePie_File" => "class-wp-simplepie-file",
100 +"class:WP_SimplePie_Sanitize_KSES" => "class-wp-simplepie-sanitize-kses",
101 +"function:wp_insert_user" => "registration",
102 +);
91 103
92 -if (isset($wp_db_version)) :
93 - if ($wp_db_version >= FWP_SCHEMA_23) :
94 - require_once (ABSPATH . WPINC . '/registration.php'); // for wp_insert_user
95 - elseif ($wp_db_version >= FWP_SCHEMA_21) : // WordPress 2.1 and 2.2, but not 2.3
96 - require_once (ABSPATH . WPINC . '/registration.php'); // for wp_insert_user
97 - require_once (ABSPATH . 'wp-admin/admin-db.php'); // for wp_insert_category
98 - elseif ($wp_db_version >= FWP_SCHEMA_20) : // WordPress 2.0
99 - require_once (ABSPATH . WPINC . '/registration-functions.php'); // for wp_insert_user
100 - require_once (ABSPATH . 'wp-admin/admin-db.php'); // for wp_insert_category
104 +// Ensure that we have SimplePie loaded up and ready to go
105 +// along with the WordPress auxiliary classes.
106 +$unmetCoreDependencies = array();
107 +foreach ($wpCoreDependencies as $unit => $fileSlug) :
108 + list($unitType, $unitName) = explode(":", $unit, 2);
109 +
110 + $dependencyMet = (('class'==$unitType) ? class_exists($unitName) : function_exists($unitName));
111 + if (!$dependencyMet) :
112 + $phpFileName = ABSPATH . WPINC . "/${fileSlug}.php";
113 + if (file_exists($phpFileName)) :
114 + require_once($phpFileName);
115 + else :
116 + $unmetCoreDependencies[] = $unitName;
117 + endif;
101 118 endif;
119 +endforeach;
120 +
121 +// Fallback garbage-pail module used in WP < 4.7 which may meet our dependencies
122 +if (count($unmetCoreDependencies) > 0) :
123 + require_once(ABSPATH . WPINC . "/class-feed.php");
102 124 endif;
103 125
104 -require_once(dirname(__FILE__) . '/compatability.php'); // LEGACY API: Replicate or mock up functions for legacy support purposes
105 -require_once(dirname(__FILE__) . '/feedwordpresshtml.class.php');
126 +// Dependences: modules packaged with FeedWordPress plugin
127 +$dir = dirname(__FILE__);
128 +require_once("${dir}/externals/myphp/myphp.class.php");
129 +require_once("${dir}/admin-ui.php");
130 +require_once("${dir}/feedwordpresssyndicationpage.class.php");
131 +require_once("${dir}/compatability.php"); // Legacy API
132 +require_once("${dir}/syndicatedpost.class.php");
133 +require_once("${dir}/syndicatedlink.class.php");
134 +require_once("${dir}/feedwordpresshtml.class.php");
135 +require_once("${dir}/feedwordpress-content-type-sniffer.class.php");
136 +require_once("${dir}/inspectpostmeta.class.php");
137 +require_once("${dir}/syndicationdataqueries.class.php");
138 +require_once("${dir}/feedwordpie.class.php");
139 +require_once("${dir}/feedwordpie_item.class.php");
140 +require_once("${dir}/feedwordpress_file.class.php");
141 +require_once("${dir}/feedwordpress_parser.class.php");
142 +require_once("${dir}/feedwordpressrpc.class.php");
143 +require_once("${dir}/feedwordpresshttpauthenticator.class.php");
144 +require_once("${dir}/feedwordpresslocalpost.class.php");
106 145
107 146 // Magic quotes are just about the stupidest thing ever.
108 147 if (is_array($_POST)) :
109 - $fwp_post = stripslashes_deep($_POST);
148 + $fwp_post = $_POST;
149 + if (get_magic_quotes_gpc()) :
150 + $fwp_post = stripslashes_deep($fwp_post);
151 + endif;
110 152 endif;
111 153
112 154 // Get the path relative to the plugins directory in which FWP is stored
113 155 preg_match (
114 - '|/wp-content/plugins/(.+)$|',
156 + '|'.preg_quote(WP_PLUGIN_DIR).'/(.+)$|',
115 157 dirname(__FILE__),
116 158 $ref
117 159 );
118 160
@@ -121,34 +163,11 @@
121 163 else : // Something went wrong. Let's just guess.
122 164 $fwp_path = 'feedwordpress';
123 165 endif;
124 166
125 -// If this is a FeedWordPress admin page, queue up scripts for AJAX functions that FWP uses
126 -// If it is a display page or a non-FeedWordPress admin page, don't.
127 -if (is_admin() and isset($_REQUEST['page']) and preg_match("|^{$fwp_path}/|", $_REQUEST['page'])) :
128 - if (function_exists('wp_enqueue_script')) :
129 - if (isset($wp_db_version) and $wp_db_version >= FWP_SCHEMA_25) :
130 - wp_enqueue_script('post'); // for magic tag and category boxes
131 - wp_enqueue_script('thickbox'); // for fold-up boxes
132 - wp_enqueue_script('admin-forms'); // for checkbox selection
133 - else :
134 - wp_enqueue_script( 'ajaxcat' ); // Provides the handy-dandy new category text box
135 - endif;
136 - endif;
137 - if (function_exists('wp_enqueue_style')) :
138 - if (fwp_test_wp_version(FWP_SCHEMA_25)) :
139 - wp_enqueue_style('dashboard');
140 - endif;
141 - endif;
142 - if (function_exists('wp_admin_css')) :
143 - if (fwp_test_wp_version(FWP_SCHEMA_25)) :
144 - wp_admin_css('css/dashboard');
145 - endif;
146 - endif;
147 -endif;
167 +$feedwordpress = new FeedWordPress;
168 +if (!$feedwordpress->needs_upgrade()) : // only work if the conditions are safe!
148 169
149 -if (!FeedWordPress::needs_upgrade()) : // only work if the conditions are safe!
150 -
151 170 # Syndicated items are generally received in output-ready (X)HTML and
152 171 # should not be folded, crumpled, mutilated, or spindled by WordPress
153 172 # formatting filters. But we don't want to interfere with filters for
154 173 # any locally-authored posts, either.
@@ -162,14 +181,22 @@
162 181 # this is a syndicated post
163 182
164 183 add_filter('the_content', 'feedwordpress_preserve_syndicated_content', -10000);
165 184 add_filter('the_content', 'feedwordpress_restore_syndicated_content', 10000);
166 -
185 +
167 186 add_action('atom_entry', 'feedwordpress_item_feed_data');
168 -
187 +
169 188 # Filter in original permalinks if the user wants that
170 - add_filter('post_link', 'syndication_permalink', 1);
189 + add_filter('post_link', 'syndication_permalink', /*priority=*/ 1, /*arguments=*/ 3);
190 + add_filter('post_type_link', 'syndication_permalink', /*priority=*/ 1, /*arguments=*/ 4);
171 191
192 + # When foreign URLs are used for permalinks in feeds or display
193 + # contexts, they need to be escaped properly.
194 + add_filter('the_permalink', 'syndication_permalink_escaped');
195 + add_filter('the_permalink_rss', 'syndication_permalink_escaped');
196 +
197 + add_filter('post_comments_feed_link', 'syndication_comments_feed_link');
198 +
172 199 # WTF? By default, wp_insert_link runs incoming link_url and link_rss
173 200 # URIs through default filters that include `wp_kses()`. But `wp_kses()`
174 201 # just happens to escape any occurrence of & to &amp; -- which just
175 202 # happens to fuck up any URI with a & to separate GET parameters.
@@ -174,18 +201,22 @@
174 201 # just happens to escape any occurrence of & to &amp; -- which just
175 202 # happens to fuck up any URI with a & to separate GET parameters.
176 203 remove_filter('pre_link_rss', 'wp_filter_kses');
177 204 remove_filter('pre_link_url', 'wp_filter_kses');
178 -
205 +
179 206 # Admin menu
207 + add_action('admin_init', array($feedwordpress, 'admin_init'));
180 208 add_action('admin_menu', 'fwp_add_pages');
181 209 add_action('admin_notices', 'fwp_check_debug');
182 - add_action('admin_notices', 'fwp_check_magpie');
183 - add_action('init', 'feedwordpress_check_for_magpie_fix');
184 210
211 + add_action('admin_menu', 'feedwordpress_add_post_edit_controls');
212 + add_action('save_post', 'feedwordpress_save_post_edit_controls');
213 +
214 + add_action('admin_footer', array($feedwordpress, 'admin_footer'));
215 +
185 216 # Inbound XML-RPC update methods
186 - add_filter('xmlrpc_methods', 'feedwordpress_xmlrpc_hook');
187 -
217 + $feedwordpressRPC = new FeedWordPressRPC;
218 +
188 219 # Outbound XML-RPC ping reform
189 220 remove_action('publish_post', 'generic_ping'); // WP 1.5.x
190 221 remove_action('do_pings', 'do_all_pings', 10, 1); // WP 2.1, 2.2
191 222 remove_action('publish_post', '_publish_post_hook', 5, 1); // WP 2.3
@@ -194,322 +225,280 @@
194 225 add_action('do_pings', 'fwp_do_pings', 10, 1);
195 226 add_action('feedwordpress_update', 'fwp_hold_pings');
196 227 add_action('feedwordpress_update_complete', 'fwp_release_pings');
197 228
198 - # Hook in logging functions only if the logging option is ON
199 - $update_logging = get_option('feedwordpress_update_logging');
200 - if ($update_logging == 'yes') :
201 - add_action('post_syndicated_item', 'log_feedwordpress_post', 100);
202 - add_action('update_syndicated_item', 'log_feedwordpress_update_post', 100);
203 - add_action('feedwordpress_update', 'log_feedwordpress_update_feeds', 100);
204 - add_action('feedwordpress_check_feed', 'log_feedwordpress_check_feed', 100);
205 - add_action('feedwordpress_update_complete', 'log_feedwordpress_update_complete', 100);
206 - endif;
207 -
208 - if (FeedWordPress::update_requested() and FEEDWORDPRESS_DEBUG) :
209 - add_action('post_syndicated_item', 'debug_out_feedwordpress_post', 100);
210 - add_action('update_syndicated_item', 'debug_out_feedwordpress_update_post', 100);
211 - add_action('feedwordpress_update', 'debug_out_feedwordpress_update_feeds', 100);
212 - add_action('feedwordpress_check_feed', 'debug_out_feedwordpress_check_feed', 100);
213 - add_action('feedwordpress_update_complete', 'debug_out_feedwordpress_update_complete', 100);
214 - endif;
229 + add_action('syndicated_feed_error', array('FeedWordPressDiagnostic', 'feed_error'), 100, 3);
215 230
231 + add_action('wp_footer', 'debug_out_feedwordpress_footer', -100);
232 + add_action('admin_footer', 'debug_out_feedwordpress_footer', -100);
233 +
216 234 # Cron-less auto-update. Hooray!
217 - $autoUpdateHook = get_option('feedwordpress_automatic_updates');
218 - if ($autoUpdateHook != 'init') :
219 - $autoUpdateHook = 'shutdown';
235 + $autoUpdateHook = $feedwordpress->automatic_update_hook();
236 + if (!is_null($autoUpdateHook)) :
237 + add_action($autoUpdateHook, array($feedwordpress, 'auto_update'));
220 238 endif;
221 - add_action($autoUpdateHook, 'feedwordpress_auto_update');
222 239
223 - add_action('init', 'feedwordpress_update_magic_url');
240 + add_action('init', array($feedwordpress, 'init'));
241 + add_action('wp_loaded', array($feedwordpress, 'wp_loaded'));
224 242
243 + add_action('shutdown', array($feedwordpress, 'email_diagnostic_log'));
244 + add_action('shutdown', array($feedwordpress, 'feedwordpress_cleanup'));
245 + add_action('wp_dashboard_setup', array($feedwordpress, 'dashboard_setup'));
246 +
225 247 # Default sanitizers
226 248 add_filter('syndicated_item_content', array('SyndicatedPost', 'resolve_relative_uris'), 0, 2);
227 249 add_filter('syndicated_item_content', array('SyndicatedPost', 'sanitize_content'), 0, 2);
228 250
251 + add_action('plugins_loaded', array($feedwordpress, 'admin_api'));
252 + add_action('all_admin_notices', array($feedwordpress, 'all_admin_notices'));
253 +
229 254 else :
230 255 # Hook in the menus, which will just point to the upgrade interface
231 256 add_action('admin_menu', 'fwp_add_pages');
232 257 endif; // if (!FeedWordPress::needs_upgrade())
233 258
234 -function feedwordpress_check_for_magpie_fix () {
235 - if (isset($_POST['action']) and $_POST['action']=='fix_magpie_version') :
236 - FeedWordPressCompatibility::validate_http_request(/*action=*/ 'feedwordpress_fix_magpie', /*capability=*/ 'edit_files');
237 -
238 - $back_to = $_SERVER['REQUEST_URI'];
239 - if (isset($_POST['ignore'])) :
240 - // kill error message by telling it we ignored the upgrade request for this version
241 - update_option('feedwordpress_magpie_ignored_upgrade_to', EXPECTED_MAGPIE_VERSION);
242 - $ret = 'ignored';
243 - elseif (isset($_POST['upgrade'])) :
244 - $source = dirname(__FILE__)."/MagpieRSS-upgrade/rss.php";
245 - $destination = ABSPATH . WPINC . '/rss.php';
246 - $success = @copy($source, $destination);
247 -
248 - // Copy over rss-functions.php, too, to avoid collisions
249 - // on pre-lapsarian versions of WordPress.
250 - if ($success) :
251 - $source = dirname(__FILE__)."/MagpieRSS-upgrade/rss-functions.php";
252 - $destination = ABSPATH . WPINC . '/rss-functions.php';
253 - $success = @copy($source, $destination);
254 - endif;
255 - $ret = (int) $success;
256 - endif;
257 -
258 - if (strpos($back_to, '?')===false) : $sep = '?';
259 - else : $sep = '&';
260 - endif;
261 -
262 - header("Location: {$back_to}{$sep}feedwordpress_magpie_fix=".$ret);
263 - exit;
264 - endif;
265 -} /* feedwordpress_check_for_magpie_fix() */
266 -
267 -function feedwordpress_auto_update () {
268 - if (FeedWordPress::stale()) :
269 - $feedwordpress =& new FeedWordPress;
270 - $feedwordpress->update();
271 - endif;
272 -} /* feedwordpress_auto_update () */
273 -
274 -function feedwordpress_update_magic_url () {
275 - // Explicit update request in the HTTP request (e.g. from a cron job)
276 - if (FeedWordPress::update_requested()) :
277 - $feedwordpress =& new FeedWordPress;
278 - $feedwordpress->update(FeedWordPress::update_requested_url());
279 -
280 - // Magic URL should return nothing but a 200 OK header packet
281 - // when successful.
282 - exit;
283 - endif;
284 -} /* feedwordpress_magic_update_url () */
285 -
286 259 ################################################################################
287 260 ## LOGGING FUNCTIONS: log status updates to error_log if you want it ###########
288 261 ################################################################################
289 262
290 -function log_feedwordpress_post ($id) {
291 - $post = wp_get_single_post($id);
292 - error_log("[".date('Y-m-d H:i:s')."][feedwordpress] posted "
293 - ."'{$post->post_title}' ({$post->post_date})");
294 -}
263 +class FeedWordPressDiagnostic {
264 + public static function feed_error ($error, $old, $link) {
265 + $wpError = $error['object'];
266 + $url = $link->uri();
267 +
268 + // check for effects of an effective-url filter
269 + $effectiveUrl = $link->uri(array('fetch' => true));
270 + if ($url != $effectiveUrl) : $url .= ' | ' . $effectiveUrl; endif;
295 271
296 -function log_feedwordpress_update_post ($id) {
297 - $post = wp_get_single_post($id);
298 - error_log("[".date('Y-m-d H:i:s')."][feedwordpress] updated "
299 - ."'{$post->post_title}' ({$post->post_date})"
300 - ." (as of {$post->post_modified})");
301 -}
272 + $mesgs = $wpError->get_error_messages();
273 + foreach ($mesgs as $mesg) :
274 + $mesg = esc_html($mesg);
275 + FeedWordPress::diagnostic(
276 + 'updated_feeds:errors',
277 + "Feed Error: [${url}] update returned error: $mesg"
278 + );
302 279
303 -function log_feedwordpress_update_feeds ($uri) {
304 - error_log("[".date('Y-m-d H:i:s')."][feedwordpress] update('$uri')");
305 -}
280 + $hours = get_option('feedwordpress_diagnostics_persistent_errors_hours', 2);
281 + $span = ($error['ts'] - $error['since']);
306 282
307 -function log_feedwordpress_check_feed ($feed) {
308 - $uri = $feed['link/uri']; $name = $feed['link/name'];
309 - error_log("[".date('Y-m-d H:i:s')."][feedwordpress] Examining $name <$uri>");
310 -}
283 + if ($span >= ($hours * 60 * 60)) :
284 + $since = date('r', $error['since']);
285 + $mostRecent = date('r', $error['ts']);
286 + FeedWordPress::diagnostic(
287 + 'updated_feeds:errors:persistent',
288 + "Feed Update Error: [${url}] returning errors"
289 + ." since ${since}:<br/><code>$mesg</code>",
290 + $url, $error['since'], $error['ts']
291 + );
292 + endif;
293 + endforeach;
294 + }
311 295
312 -function log_feedwordpress_update_complete ($delta) {
313 - $mesg = array();
314 - if (isset($delta['new'])) $mesg[] = 'added '.$delta['new'].' new posts';
315 - if (isset($delta['updated'])) $mesg[] = 'updated '.$delta['updated'].' existing posts';
316 - if (empty($mesg)) $mesg[] = 'nothing changed';
296 + function admin_emails ($id = '') {
297 + $users = get_users_of_blog($id);
298 + $recipients = array();
299 + foreach ($users as $user) :
300 + $user_id = (isset($user->user_id) ? $user->user_id : $user->ID);
301 + $dude = new WP_User($user_id);
302 + if ($dude->has_cap('administrator')) :
303 + if ($dude->user_email) :
304 + $recipients[] = $dude->user_email;
305 + endif;
306 + endif;
307 + endforeach;
308 + return $recipients;
309 + }
310 +} /* class FeedWordPressDiagnostic */
317 311
318 - error_log("[".date('Y-m-d H:i:s')."][feedwordpress] "
319 - .(is_null($delta) ? "Error: I don't syndicate that URI"
320 - : implode(' and ', $mesg)));
312 +function debug_out_human_readable_bytes ($quantity) {
313 + $quantity = (int) $quantity;
314 + $magnitude = 'B';
315 + $orders = array('KB', 'MB', 'GB', 'TB');
316 + while (($quantity > (1024*100)) and (count($orders) > 0)) :
317 + $quantity = floor($quantity / 1024);
318 + $magnitude = array_shift($orders);
319 + endwhile;
320 + return "${quantity} ${magnitude}";
321 321 }
322 322
323 -function debug_out_feedwordpress_post ($id) {
324 - $post = wp_get_single_post($id);
325 - print ("[".date('Y-m-d H:i:s')."][feedwordpress] posted "
326 - ."'{$post->post_title}' ({$post->post_date})\n");
327 -}
323 +function debug_out_feedwordpress_footer () {
324 + if (FeedWordPress::diagnostic_on('memory_usage')) :
325 + if (function_exists('memory_get_usage')) :
326 + FeedWordPress::diagnostic ('memory_usage', "Memory: Current usage: ".debug_out_human_readable_bytes(memory_get_usage()));
327 + endif;
328 + if (function_exists('memory_get_peak_usage')) :
329 + FeedWordPress::diagnostic ('memory_usage', "Memory: Peak usage: ".debug_out_human_readable_bytes(memory_get_peak_usage()));
330 + endif;
331 + endif;
332 +} /* debug_out_feedwordpress_footer() */
328 333
329 -function debug_out_feedwordpress_update_post ($id) {
330 - $post = wp_get_single_post($id);
331 - print ("[".date('Y-m-d H:i:s')."][feedwordpress] updated "
332 - ."'{$post->post_title}' ({$post->post_date})"
333 - ." (as of {$post->post_modified})\n");
334 -}
335 -
336 -function debug_out_feedwordpress_update_feeds ($uri) {
337 - print ("[".date('Y-m-d H:i:s')."][feedwordpress] update('$uri')\n");
338 -}
339 -
340 -function debug_out_feedwordpress_check_feed ($feed) {
341 - $uri = $feed['link/uri']; $name = $feed['link/name'];
342 - print ("[".date('Y-m-d H:i:s')."][feedwordpress] Examining $name <$uri>\n");
343 -}
344 -
345 -function debug_out_feedwordpress_update_complete ($delta) {
346 - $mesg = array();
347 - if (isset($delta['new'])) $mesg[] = 'added '.$delta['new'].' new posts';
348 - if (isset($delta['updated'])) $mesg[] = 'updated '.$delta['updated'].' existing posts';
349 - if (empty($mesg)) $mesg[] = 'nothing changed';
350 -
351 - print ("[".date('Y-m-d H:i:s')."][feedwordpress] "
352 - .(is_null($delta) ? "Error: I don't syndicate that URI"
353 - : implode(' and ', $mesg))."\n");
354 -}
355 -
356 334 ################################################################################
357 335 ## TEMPLATE API: functions to make your templates syndication-aware ############
358 336 ################################################################################
359 337
360 -function is_syndicated ($id = NULL) { return (strlen(get_syndication_feed_id($id)) > 0); }
338 +/**
339 + * is_syndicated: Tests whether the current post in a Loop context, or a post
340 + * given by ID number, was syndicated by FeedWordPress. Useful for templates
341 + * to determine whether or not to retrieve syndication-related meta-data in
342 + * displaying a post.
343 + *
344 + * @param int $id The post to check for syndicated status. Defaults to the current post in a Loop context.
345 + * @return bool TRUE if the post's meta-data indicates it was syndicated; FALSE otherwise
346 + */
347 +function is_syndicated ($id = NULL) {
348 + $p = new FeedWordPressLocalPost($id);
349 + return $p->is_syndicated();
350 +} /* function is_syndicated() */
361 351
362 -function get_syndication_source_link ($original = NULL, $id = NULL) {
363 - if (is_null($original)) : $original = FeedWordPress::use_aggregator_source_data();
364 - endif;
365 -
366 - if ($original) : $vals = get_post_custom_values('syndication_source_uri_original', $id);
367 - else : $vals = array();
368 - endif;
369 -
370 - if (count($vals) == 0) : $vals = get_post_custom_values('syndication_source_uri', $id);
371 - endif;
372 -
373 - if (count($vals) > 0) : $ret = $vals[0]; else : $ret = NULL; endif;
374 -
375 - return $ret;
376 -} /* function get_syndication_source_link() */
377 -
378 -function the_syndication_source_link ($original = NULL, $id = NULL) {
379 - echo get_syndication_source_link($original, $id);
380 -}
381 -
382 352 function feedwordpress_display_url ($url, $before = 60, $after = 0) {
383 353 $bits = parse_url($url);
384 -
354 +
385 355 // Strip out crufty subdomains
386 - $bits['host'] = preg_replace('/^www[0-9]*\./i', '', $bits['host']);
356 + if (isset($bits['host'])) :
357 + $bits['host'] = preg_replace('/^www[0-9]*\./i', '', $bits['host']);
358 + endif;
387 359
388 360 // Reassemble bit-by-bit with minimum of crufty elements
389 361 $url = (isset($bits['user'])?$bits['user'].'@':'')
390 362 .(isset($bits['host'])?$bits['host']:'')
391 363 .(isset($bits['path'])?$bits['path']:'')
364 + .(isset($uri_bits['port'])?':'.$uri_bits['port']:'')
392 365 .(isset($bits['query'])?'?'.$bits['query']:'');
393 366
394 367 if (strlen($url) > ($before+$after)) :
395 - $url = substr($url, 0, $before).'…'.substr($url, 0 - $after, $after);
368 + $url = substr($url, 0, $before).'.'.substr($url, 0 - $after, $after);
396 369 endif;
397 370
398 371 return $url;
399 -}
372 +} /* feedwordpress_display_url () */
400 373
401 -function get_syndication_source ($original = NULL, $id = NULL) {
402 - if (is_null($original)) :
403 - $original = FeedWordPress::use_aggregator_source_data();
404 - endif;
374 +function get_syndication_source_property ($original, $id, $local, $remote = NULL) {
375 + $p = new FeedWordPressLocalPost($id);
376 + return $p->meta($local, array("unproxy" => $original, "unproxied setting" => $remote));
377 +} /* function get_syndication_source_property () */
405 378
406 - if ($original) :
407 - $vals = get_post_custom_values('syndication_source_original', $id);
408 - else :
409 - $vals = array();
410 - endif;
411 -
412 - if (count($vals) == 0) :
413 - $vals = get_post_custom_values('syndication_source', $id);
414 - endif;
415 -
416 - if (count($vals) > 0) :
417 - $ret = $vals[0];
418 - else :
419 - $ret = NULL;
420 - endif;
379 +function get_syndication_source_link ($original = NULL, $id = NULL) {
380 + $p = new FeedWordPressLocalPost($id);
381 + return $p->syndication_source_link($original);
382 +} /* function get_syndication_source_link() */
421 383
422 - if (is_null($ret) or strlen(trim($ret)) == 0) :
423 - // Fall back to URL of blog
424 - $ret = feedwordpress_display_url(get_syndication_source_link());
425 - endif;
384 +function the_syndication_source_link ($original = NULL, $id = NULL) {
385 + echo get_syndication_source_link($original, $id);
386 +} /* function the_syndication_source_link() */
426 387
427 - return $ret;
388 +function get_syndication_source ($original = NULL, $id = NULL) {
389 + $p = new FeedWordPressLocalPost($id);
390 + return $p->syndication_source($original);
428 391 } /* function get_syndication_source() */
429 392
430 -function the_syndication_source ($original = NULL, $id = NULL) { echo get_syndication_source($original, $id); }
393 +function the_syndication_source ($original = NULL, $id = NULL) {
394 + echo get_syndication_source($original, $id);
395 +} /* function the_syndication_source () */
431 396
432 397 function get_syndication_feed ($original = NULL, $id = NULL) {
433 - if (is_null($original)) : $original = FeedWordPress::use_aggregator_source_data();
434 - endif;
435 -
436 - if ($original) : $vals = get_post_custom_values('syndication_feed_original', $id);
437 - else : $vals = array();
438 - endif;
439 -
440 - if (count($vals) == 0) : $vals = get_post_custom_values('syndication_feed', $id);
441 - endif;
442 -
443 - if (count($vals) > 0) : $ret = $vals[0]; else : $ret = NULL; endif;
444 -
445 - return $ret;
398 + $p = new FeedWordPressLocalPost($id);
399 + return $p->syndication_feed($original);
446 400 } /* function get_syndication_feed() */
447 401
448 -function the_syndication_feed ($original = NULL, $id = NULL) { echo get_syndication_feed($original, $id); }
402 +function the_syndication_feed ($original = NULL, $id = NULL) {
403 + echo get_syndication_feed($original, $id);
404 +} /* function the_syndication_feed() */
449 405
450 406 function get_syndication_feed_guid ($original = NULL, $id = NULL) {
451 - if (is_null($original)) : $original = FeedWordPress::use_aggregator_source_data();
452 - endif;
407 + $p = new FeedWordPressLocalPost($id);
408 + return $p->syndication_feed_guid($original);
409 +} /* function get_syndication_feed_guid () */
453 410
454 - if ($original) : $vals = get_post_custom_values('syndication_source_id_original', $id);
455 - else : $vals = array();
456 - endif;
457 -
458 - if (count($vals) == 0) : $vals = array(get_feed_meta('feed/id', $id));
459 - endif;
460 -
461 - if (count($vals) > 0) : $ret = $vals[0]; else : $ret = NULL; endif;
411 +function the_syndication_feed_guid ($original = NULL, $id = NULL) {
412 + echo get_syndication_feed_guid($original, $id);
413 +} /* function the_syndication_feed_guid () */
462 414
463 - return $ret;
464 -} /* function get_syndication_feed_guid () */
415 +function get_syndication_feed_id ($id = NULL) {
416 + $p = new FeedWordPressLocalPost($id);
417 + return $p->feed_id();
418 +} /* function get_syndication_feed_id () */
465 419
466 -function the_syndication_feed_guid ($original = NULL, $id = NULL) { echo get_syndication_feed_guid($original, $id); }
420 +function the_syndication_feed_id ($id = NULL) {
421 + echo get_syndication_feed_id($id);
422 +} /* function the_syndication_feed_id () */
467 423
468 -function get_syndication_feed_id ($id = NULL) { list($u) = get_post_custom_values('syndication_feed_id', $id); return $u; }
469 -function the_syndication_feed_id ($id = NULL) { echo get_syndication_feed_id($id); }
424 +function get_syndication_feed_object ($id = NULL) {
425 + $p = new FeedWordPressLocalPost($id);
426 + return $p->feed();
427 +} /* function get_syndication_feed_object() */
470 428
471 -$feedwordpress_linkcache = array (); // only load links from database once
472 -
473 429 function get_feed_meta ($key, $id = NULL) {
474 - global $wpdb, $feedwordpress_linkcache;
475 - $feed_id = get_syndication_feed_id($id);
476 -
477 430 $ret = NULL;
478 - if (strlen($feed_id) > 0):
479 - if (isset($feedwordpress_linkcache[$feed_id])) :
480 - $link = $feedwordpress_linkcache[$feed_id];
481 - else :
482 - $link =& new SyndicatedLink($feed_id);
483 - $feedwordpress_linkcache[$feed_id] = $link;
484 - endif;
485 431
432 + $link = get_syndication_feed_object($id);
433 + if (is_object($link) and isset($link->settings[$key])) :
486 434 $ret = $link->settings[$key];
487 435 endif;
488 436 return $ret;
489 -} /* get_feed_meta() */
437 +} /* function get_feed_meta() */
490 438
491 439 function get_syndication_permalink ($id = NULL) {
492 - list($u) = get_post_custom_values('syndication_permalink', $id); return $u;
493 -}
440 + $p = new FeedWordPressLocalPost($id);
441 + return $p->syndication_permalink();
442 +} /* function get_syndication_permalink () */
443 +
494 444 function the_syndication_permalink ($id = NULL) {
495 445 echo get_syndication_permalink($id);
496 -}
446 +} /* function the_syndication_permalink () */
497 447
448 +/**
449 + * get_local_permalink: returns a string containing the internal permalink
450 + * for a post (whether syndicated or not) on your local WordPress installation.
451 + * This may be useful if you want permalinks to point to the original source of
452 + * an article for most purposes, but want to retrieve a URL for the local
453 + * representation of the post for one or two limited purposes (for example,
454 + * linking to a comments page on your local aggregator site).
455 + *
456 + * @param $id The numerical ID of the post to get the permalink for. If empty,
457 + * defaults to the current post in a Loop context.
458 + * @return string The URL of the local permalink for this post.
459 + *
460 + * @uses get_permalink()
461 + * @global $feedwordpress_the_original_permalink
462 + *
463 + * @since 2010.0217
464 + */
465 +function get_local_permalink ($id = NULL) {
466 + global $feedwordpress_the_original_permalink;
467 +
468 + // get permalink, and thus activate filter and force global to be filled
469 + // with original URL.
470 + $url = get_permalink($id);
471 + return $feedwordpress_the_original_permalink;
472 +} /* get_local_permalink() */
473 +
474 +/**
475 + * the_original_permalink: displays the contents of get_original_permalink()
476 + *
477 + * @param $id The numerical ID of the post to get the permalink for. If empty,
478 + * defaults to the current post in a Loop context.
479 + *
480 + * @uses get_local_permalinks()
481 + * @uses apply_filters
482 + *
483 + * @since 2010.0217
484 + */
485 +function the_local_permalink ($id = NULL) {
486 + print apply_filters('the_permalink', get_local_permalink($id));
487 +} /* function the_local_permalink() */
488 +
498 489 ################################################################################
499 490 ## FILTERS: syndication-aware handling of post data for templates and feeds ####
500 491 ################################################################################
501 492
502 493 $feedwordpress_the_syndicated_content = NULL;
494 +$feedwordpress_the_original_permalink = NULL;
503 495
504 496 function feedwordpress_preserve_syndicated_content ($text) {
505 497 global $feedwordpress_the_syndicated_content;
506 498
507 - $globalExpose = (get_option('feedwordpress_formatting_filters') == 'yes');
508 - $localExpose = get_post_custom_values('_feedwordpress_formatting_filters');
509 - $expose = ($globalExpose or ((count($localExpose) > 0) and $localExpose[0]));
510 -
511 - if ( is_syndicated() and !$expose ) :
499 + $p = new FeedWordPressLocalPost;
500 + if (!$p->is_exposed_to_formatting_filters()) :
512 501 $feedwordpress_the_syndicated_content = $text;
513 502 else :
514 503 $feedwordpress_the_syndicated_content = NULL;
515 504 endif;
@@ -517,9 +506,9 @@
517 506 }
518 507
519 508 function feedwordpress_restore_syndicated_content ($text) {
520 509 global $feedwordpress_the_syndicated_content;
521 -
510 +
522 511 if ( !is_null($feedwordpress_the_syndicated_content) ) :
523 512 $text = $feedwordpress_the_syndicated_content;
524 513 endif;
525 514
@@ -530,16 +519,16 @@
530 519 // In a post context....
531 520 if (is_syndicated()) :
532 521 ?>
533 522 <source>
534 - <title><?php the_syndication_source(); ?></title>
535 - <link rel="alternate" type="text/html" href="<?php the_syndication_source_link(); ?>" />
536 - <link rel="self" href="<?php the_syndication_feed(); ?>" />
523 + <title><?php print htmlspecialchars(get_syndication_source()); ?></title>
524 + <link rel="alternate" type="text/html" href="<?php print htmlspecialchars(get_syndication_source_link()); ?>" />
525 + <link rel="self" href="<?php print htmlspecialchars(get_syndication_feed()); ?>" />
537 526 <?php
538 527 $id = get_syndication_feed_guid();
539 528 if (strlen($id) > 0) :
540 529 ?>
541 - <id><?php print $id; ?></id>
530 + <id><?php print htmlspecialchars($id); ?></id>
542 531 <?php
543 532 endif;
544 533 $updated = get_feed_meta('feed/updated');
545 534 if (strlen($updated) > 0) : ?>
@@ -551,37 +540,209 @@
551 540 <?php
552 541 endif;
553 542 }
554 543
555 -function syndication_permalink ($permalink = '') {
556 - if (get_option('feedwordpress_munge_permalink') != 'no'):
557 - $uri = get_syndication_permalink();
558 - return ((strlen($uri) > 0) ? $uri : $permalink);
559 - else:
560 - return $permalink;
544 +/**
545 + * syndication_permalink: Allow WordPress to use the original remote URL of
546 + * syndicated posts as their permalink. Can be turned on or off by by setting in
547 + * Syndication => Posts & Links. Saves the old internal permalink in a global
548 + * variable for later use.
549 + *
550 + * @param string $permalink The internal permalink
551 + * @return string The new permalink. Same as the old if the post is not
552 + * syndicated, or if FWP is set to use internal permalinks, or if the post
553 + * was syndicated, but didn't have a proper permalink recorded.
554 + *
555 + * @uses SyndicatedLink::setting()
556 + * @uses get_syndication_permalink()
557 + * @uses get_syndication_feed_object()
558 + * @uses url_to_postid()
559 + * @global $id
560 + * @global $feedwordpress_the_original_permalink
561 + */
562 +function syndication_permalink ($permalink = '', $post = null, $leavename = false, $sample = false) {
563 + global $id;
564 + global $feedwordpress_the_original_permalink;
565 +
566 + // Save the local permalink in case we need to retrieve it later.
567 + $feedwordpress_the_original_permalink = $permalink;
568 +
569 + if (is_object($post) and isset($post->ID) and !empty($post->ID)) :
570 + // Use the post ID we've been provided with.
571 + $postId = $post->ID;
572 + elseif (is_string($permalink) and strlen($permalink) > 0) :
573 + // Map this permalink to a post ID so we can get the correct
574 + // permalink even outside of the Post Loop. Props Björn.
575 + $postId = url_to_postid($permalink);
576 + else :
577 + // If the permalink string is empty but Post Loop context
578 + // provides an id.
579 + $postId = $id;
561 580 endif;
562 -} // function syndication_permalink ()
563 581
582 + $munge = false;
583 + $link = get_syndication_feed_object($postId);
584 + if (is_object($link)) :
585 + $munge = ($link->setting('munge permalink', 'munge_permalink', 'yes') != 'no');
586 + endif;
587 +
588 + if ($munge):
589 + $uri = get_syndication_permalink($postId);
590 + $permalink = ((strlen($uri) > 0) ? $uri : $permalink);
591 + endif;
592 + return $permalink;
593 +} /* function syndication_permalink () */
594 +
595 +/**
596 + * syndication_permalink_escaped: Escape XML special characters in syndicated
597 + * permalinks when used in feed contexts and HTML display contexts.
598 + *
599 + * @param string $permalink
600 + * @return string
601 + *
602 + * @uses is_syndicated()
603 + * @uses FeedWordPress::munge_permalinks()
604 + *
605 + */
606 +function syndication_permalink_escaped ($permalink) {
607 + /* FIXME: This should review link settings not just global settings */
608 + if (is_syndicated() and FeedWordPress::munge_permalinks()) :
609 + // This is a foreign link; WordPress can't vouch for its not
610 + // having any entities that need to be &-escaped. So we'll do
611 + // it here.
612 + $permalink = esc_html($permalink);
613 + endif;
614 + return $permalink;
615 +} /* function syndication_permalink_escaped() */
616 +
617 +/**
618 + * syndication_comments_feed_link: Escape XML special characters in comments
619 + * feed links
620 + *
621 + * @param string $link
622 + * @return string
623 + *
624 + * @uses is_syndicated()
625 + * @uses FeedWordPress::munge_permalinks()
626 + */
627 +function syndication_comments_feed_link ($link) {
628 + global $feedwordpress_the_original_permalink, $id;
629 +
630 + if (is_syndicated() and FeedWordPress::munge_permalinks()) :
631 + // If the source post provided a comment feed URL using
632 + // wfw:commentRss or atom:link/@rel="replies" we can make use of
633 + // that value here.
634 + $source = get_syndication_feed_object();
635 + $replacement = NULL;
636 +
637 + if (is_object($source) && $source->setting('munge comments feed links', 'munge_comments_feed_links', 'yes') != 'no') :
638 + $commentFeeds = get_post_custom_values('wfw:commentRSS');
639 + if (
640 + is_array($commentFeeds)
641 + and (count($commentFeeds) > 0)
642 + and (strlen($commentFeeds[0]) > 0)
643 + ) :
644 + $replacement = $commentFeeds[0];
645 +
646 + // This is a foreign link; WordPress can't vouch for its not
647 + // having any entities that need to be &-escaped. So we'll do it
648 + // here.
649 + $replacement = esc_html($replacement);
650 + endif;
651 + endif;
652 +
653 + if (is_null($replacement)) :
654 + // Q: How can we get the proper feed format, since the
655 + // format is, stupidly, not passed to the filter?
656 + // A: Kludge kludge kludge kludge!
657 + $fancy_permalinks = ('' != get_option('permalink_structure'));
658 + if ($fancy_permalinks) :
659 + preg_match('|/feed(/([^/]+))?/?$|', $link, $ref);
660 +
661 + $format = (isset($ref[2]) ? $ref[2] : '');
662 + if (strlen($format) == 0) : $format = get_default_feed(); endif;
663 +
664 + $replacement = trailingslashit($feedwordpress_the_original_permalink) . 'feed';
665 + if ($format != get_default_feed()) :
666 + $replacement .= '/'.$format;
667 + endif;
668 + $replacement = user_trailingslashit($replacement, 'single_feed');
669 + else :
670 + // No fancy permalinks = no problem
671 + // WordPress doesn't call get_permalink() to
672 + // generate the comment feed URL, so the
673 + // comments feed link is never munged by FWP.
674 + endif;
675 + endif;
676 +
677 + if (!is_null($replacement)) : $link = $replacement; endif;
678 + endif;
679 + return $link;
680 +} /* function syndication_comments_feed_link() */
681 +
564 682 ################################################################################
565 683 ## ADMIN MENU ADD-ONS: register Dashboard management pages #####################
566 684 ################################################################################
567 685
568 686 function fwp_add_pages () {
569 - global $fwp_capability;
570 - global $fwp_path;
687 + global $feedwordpress;
571 688
572 - $menu = array('Syndicated Sites', 'Syndication', $fwp_capability['manage_links'], $fwp_path.'/syndication.php', NULL);
573 - if (fwp_test_wp_version(FWP_SCHEMA_27)) :
574 - // add icon parameter
575 - $menu[] = WP_PLUGIN_URL.'/'.$fwp_path.'/feedwordpress-tiny.png';
576 - endif;
689 + $menu_cap = FeedWordPress::menu_cap();
690 + $settings_cap = FeedWordPress::menu_cap(/*sub=*/ true);
691 + $syndicationMenu = FeedWordPress::path('syndication.php');
577 692
578 - call_user_func_array('add_menu_page', $menu);
579 - add_submenu_page($fwp_path.'/syndication.php', 'Syndicated Feeds & Updates', 'Feeds & Updates', $fwp_capability['manage_options'], $fwp_path.'/feeds-page.php');
580 - add_submenu_page($fwp_path.'/syndication.php', 'Syndicated Posts & Links', 'Posts & Links', $fwp_capability['manage_options'], $fwp_path.'/posts-page.php');
581 - add_submenu_page($fwp_path.'/syndication.php', 'Syndicated Authors', 'Authors', $fwp_capability['manage_options'], $fwp_path.'/authors-page.php');
582 - add_submenu_page($fwp_path.'/syndication.php', 'Categories'.FEEDWORDPRESS_AND_TAGS, 'Categories'.FEEDWORDPRESS_AND_TAGS, $fwp_capability['manage_options'], $fwp_path.'/categories-page.php');
583 - add_submenu_page($fwp_path.'/syndication.php', 'FeedWordPress Back End', 'Back End', $fwp_capability['manage_options'], $fwp_path.'/backend-page.php');
693 + add_menu_page(
694 + 'Syndicated Sites', 'Syndication',
695 + $menu_cap,
696 + $syndicationMenu,
697 + NULL,
698 + plugins_url( '/'.FeedWordPress::path('feedwordpress-tiny.png') )
699 + );
700 +
701 + do_action('feedwordpress_admin_menu_pre_feeds', $menu_cap, $settings_cap);
702 + add_submenu_page(
703 + $syndicationMenu, 'Syndicated Sites', 'Syndicated Sites',
704 + $settings_cap, $syndicationMenu
705 + );
706 +
707 + do_action('feedwordpress_admin_menu_pre_feeds', $menu_cap, $settings_cap);
708 + add_submenu_page(
709 + $syndicationMenu, 'Syndicated Feeds & Updates', 'Feeds & Updates',
710 + $settings_cap, FeedWordPress::path('feeds-page.php')
711 + );
712 +
713 + do_action('feedwordpress_admin_menu_pre_posts', $menu_cap, $settings_cap);
714 + add_submenu_page(
715 + $syndicationMenu, 'Syndicated Posts & Links', 'Posts & Links',
716 + $settings_cap, FeedWordPress::path('posts-page.php')
717 + );
718 +
719 + do_action('feedwordpress_admin_menu_pre_authors', $menu_cap, $settings_cap);
720 + add_submenu_page(
721 + $syndicationMenu, 'Syndicated Authors', 'Authors',
722 + $settings_cap, FeedWordPress::path('authors-page.php')
723 + );
724 +
725 + do_action('feedwordpress_admin_menu_pre_categories', $menu_cap, $settings_cap);
726 + add_submenu_page(
727 + $syndicationMenu, 'Categories & Tags', 'Categories & Tags',
728 + $settings_cap, FeedWordPress::path('categories-page.php')
729 + );
730 +
731 + do_action('feedwordpress_admin_menu_pre_performance', $menu_cap, $settings_cap);
732 + add_submenu_page(
733 + $syndicationMenu, 'FeedWordPress Performance', 'Performance',
734 + $settings_cap, FeedWordPress::path('performance-page.php')
735 + );
736 +
737 + do_action('feedwordpress_admin_menu_pre_diagnostics', $menu_cap, $settings_cap);
738 + add_submenu_page(
739 + $syndicationMenu, 'FeedWordPress Diagnostics', 'Diagnostics',
740 + $settings_cap, FeedWordPress::path('diagnostics-page.php')
741 + );
742 +
743 + add_filter('page_row_actions', array($feedwordpress, 'row_actions'), 10, 2);
744 + add_filter('post_row_actions', array($feedwordpress, 'row_actions'), 10, 2);
584 745 } /* function fwp_add_pages () */
585 746
586 747 function fwp_check_debug () {
587 748 // This is a horrible fucking kludge that I have to do because the
@@ -604,97 +765,8 @@
604 765 <?php
605 766 endif;
606 767 } /* function fwp_check_debug () */
607 768
608 -define('EXPECTED_MAGPIE_VERSION', '2009.0725');
609 -function fwp_check_magpie () {
610 - if (isset($_REQUEST['feedwordpress_magpie_fix'])) :
611 - if ($_REQUEST['feedwordpress_magpie_fix']=='ignored') :
612 -?>
613 -<div class="updated fade">
614 -<p>O.K., we'll ignore the problem for now. FeedWordPress will not display any
615 -more error messages.</p>
616 -</div>
617 -<?php
618 - elseif ((bool) $_REQUEST['feedwordpress_magpie_fix']) :
619 -?>
620 -<div class="updated fade">
621 -<p>Congratulations! Your MagpieRSS has been successfully upgraded to the version
622 -shipped with FeedWordPress.</p>
623 -</div>
624 -<?php
625 - else :
626 - $source = dirname(__FILE__)."/MagpieRSS-upgrade/rss.php";
627 - $destination = ABSPATH . WPINC . '/rss.php';
628 - $cmd = "cp '".htmlspecialchars(addslashes($source))."' '".htmlspecialchars(addslashes($destination))."'";
629 - $cmd = wordwrap($cmd, /*width=*/ 75, /*break=*/ " \\\n\t");
630 -
631 -?>
632 -<div class="error">
633 -<p><strong>FeedWordPress was unable to automatically upgrade your copy of MagpieRSS.</strong></p>
634 -<p>It's likely that you need to change the file permissions on <code><?php print htmlspecialchars($source); ?></code>
635 -to allow FeedWordPress to overwrite it.</p>
636 -<p><strong>To perform the upgrade manually,</strong> you can
637 -use a SFTP or FTP client to upload a copy of <code>rss.php</code> from the
638 -<code>MagpieRSS-upgrades/</code> directory of your FeedWordPress archive so that
639 -it overwrites <code><?php print htmlspecialchars($destination); ?></code>. Or,
640 -if your web host provides shell access, you can issue the following command from
641 -a command prompt to perform the upgrade:</p>
642 -<pre>
643 -<samp>$</samp> <kbd><?php print $cmd; ?></kbd>
644 -</pre>
645 -<p><strong>If you've fixed the file permissions,</strong> you can try the
646 -automatic upgrade again.</p>
647 -
648 -<?php feedwordpress_upgrade_old_and_busted_buttons(); ?>
649 -</div>
650 -<?php
651 - endif;
652 - else :
653 - $magpie_version = FeedWordPress::magpie_version();
654 -
655 - $ignored = get_option('feedwordpress_magpie_ignored_upgrade_to');
656 - if (EXPECTED_MAGPIE_VERSION != $magpie_version and EXPECTED_MAGPIE_VERSION != $ignored) :
657 - if (current_user_can('edit_files')) :
658 - $youAre = 'you are';
659 - $itIsRecommendedThatYou = 'It is <strong>strongly recommended</strong> that you';
660 - else :
661 - $youAre = 'this site is';
662 - $itIsRecommendedThatYou = 'You may want to contact the administrator of the site; it is <strong>strongly recommended</strong> that they';
663 - endif;
664 - print '<div class="error">';
665 -?>
666 -<p style="font-style: italic"><strong>FeedWordPress has detected that <?php print $youAre; ?> currently using a version of
667 -MagpieRSS other than the upgraded version that ships with this version of FeedWordPress.</strong></p>
668 -<ul>
669 -<li><strong>Currently running:</strong> MagpieRSS <?php print $magpie_version; ?></li>
670 -<li><strong>Version included with FeedWordPress <?php print FEEDWORDPRESS_VERSION; ?>:</strong> MagpieRSS <?php print EXPECTED_MAGPIE_VERSION; ?></li>
671 -</ul>
672 -<p><?php print $itIsRecommendedThatYou; ?> install the upgraded
673 -version of MagpieRSS supplied with FeedWordPress. The version of
674 -MagpieRSS that ships with WordPress is very old and buggy, and
675 -encounters a number of errors when trying to parse modern Atom
676 -and RSS feeds.</p>
677 -<?php
678 - feedwordpress_upgrade_old_and_busted_buttons();
679 - print '</div>';
680 - endif;
681 - endif;
682 -}
683 -
684 -function feedwordpress_upgrade_old_and_busted_buttons() {
685 - if (current_user_can('edit_files')) :
686 -?>
687 -<form action="" method="post"><div>
688 -<?php FeedWordPressCompatibility::stamp_nonce('feedwordpress_fix_magpie'); ?>
689 -<input type="hidden" name="action" value="fix_magpie_version" />
690 -<input class="button-secondary" type="submit" name="ignore" value="<?php _e('Ignore this problem'); ?>" />
691 -<input class="button-primary" type="submit" name="upgrade" value="<?php _e('Upgrade'); ?>" />
692 -</div></form>
693 -<?php
694 - endif;
695 -}
696 -
697 769 ################################################################################
698 770 ## fwp_hold_pings() and fwp_release_pings(): Outbound XML-RPC ping reform ####
699 771 ## ... 'coz it's rude to send 500 pings the first time your aggregator runs ####
700 772 ################################################################################
@@ -737,9 +809,9 @@
737 809 if ( defined('XMLRPC_REQUEST') )
738 810 do_action('xmlrpc_publish_post', $post_id);
739 811 if ( defined('APP_REQUEST') )
740 812 do_action('app_publish_post', $post_id);
741 -
813 +
742 814 if ( defined('WP_IMPORTING') )
743 815 return;
744 816
745 817 // Defer sending out pings until we finish updating
@@ -750,8 +822,112 @@
750 822 endif;
751 823 endif;
752 824 }
753 825
826 + function feedwordpress_add_post_edit_controls () {
827 + global $feedwordpress;
828 + global $inspectPostMeta;
829 +
830 + // Put in Manual Editing checkbox
831 + add_action('add_meta_boxes', 'feedwordpress_post_add_meta_boxes', 10, 2);
832 +
833 + add_filter('user_can_richedit', array($feedwordpress, 'user_can_richedit'), 1000, 1);
834 +
835 + if (FeedWordPress::diagnostic_on('syndicated_posts:static_meta_data')) :
836 + $inspectPostMeta = new InspectPostMeta;
837 + endif;
838 + } // function feedwordpress_add_post_edit_controls ()
839 +
840 + function feedwordpress_post_add_meta_boxes ($post_type, $post) {
841 + add_meta_box(
842 + 'feedwordpress-post-controls',
843 + __('Syndication'),
844 + 'feedwordpress_post_edit_controls',
845 + $post_type,
846 + 'side',
847 + 'high'
848 + );
849 + }
850 +
851 + function feedwordpress_post_edit_controls () {
852 + global $post;
853 +
854 + $frozen_values = get_post_custom_values('_syndication_freeze_updates', $post->ID);
855 + $frozen_post = (count($frozen_values) > 0 and 'yes' == $frozen_values[0]);
856 +
857 + if (is_syndicated($post->ID)) :
858 + ?>
859 + <p>This is a syndicated post, which originally appeared at
860 + <cite><?php print esc_html(get_syndication_source(NULL, $post->ID)); ?></cite>.
861 + <a href="<?php print esc_html(get_syndication_permalink($post->ID)); ?>">View original post</a>.</p>
862 +
863 + <?php do_action('feedwordpress_post_edit_controls_pre', $post); ?>
864 +
865 + <p><input type="hidden" name="feedwordpress_noncename" id="feedwordpress_noncename" value="<?php print wp_create_nonce(plugin_basename(__FILE__)); ?>" />
866 + <label><input type="checkbox" name="freeze_updates" value="yes" <?php if ($frozen_post) : ?>checked="checked"<?php endif; ?> /> <strong>Manual editing.</strong>
867 + If set, FeedWordPress will not overwrite the changes you make manually
868 + to this post, if the syndicated content is updated on the
869 + feed.</label></p>
870 +
871 + <?php do_action('feedwordpress_post_edit_controls', $post); ?>
872 +
873 + <?php
874 + else :
875 + ?>
876 + <p>This post was created locally at this website.</p>
877 + <?php
878 + endif;
879 + } /* function feedwordpress_post_edit_controls () */
880 +
881 + function feedwordpress_save_post_edit_controls ( $post_id ) {
882 + global $post;
883 + if (!isset($_POST['feedwordpress_noncename']) or !wp_verify_nonce($_POST['feedwordpress_noncename'], plugin_basename(__FILE__))) :
884 + return $post_id;
885 + endif;
886 +
887 + // Verify if this is an auto save routine. If it is our form has
888 + // not been submitted, so we don't want to do anything.
889 + if ( defined('DOING_AUTOSAVE') and DOING_AUTOSAVE ) :
890 + return $post_id;
891 + endif;
892 +
893 + // The data in $_POST is for applying only to the post actually
894 + // in the edit window, i.e. $post
895 + if ($post_id != $post->ID) :
896 + return $post_id;
897 + endif;
898 +
899 + // Check permissions
900 + $cap[0] = 'edit_post';
901 + $cap[1] = 'edit_' . $_POST['post_type'];
902 + if (
903 + !current_user_can( $cap[0], $post_id )
904 + and !current_user_can( $cap[1], $post_id )
905 + ) :
906 + return $post_id;
907 + endif;
908 +
909 + // OK, we're golden. Now let's save some data.
910 + if (isset($_POST['freeze_updates'])) :
911 +
912 + update_post_meta($post_id, '_syndication_freeze_updates', $_POST['freeze_updates']);
913 + $ret = $_POST['freeze_updates'];
914 +
915 + // If you make manual edits through the WordPress editing
916 + // UI then they should be run through normal WP formatting
917 + // filters.
918 + update_post_meta($post_id, '_feedwordpress_formatting_filters', 'yes');
919 +
920 + else :
921 + delete_post_meta($post_id, '_syndication_freeze_updates');
922 + $ret = NULL;
923 + endif;
924 +
925 + do_action('feedwordpress_save_edit_controls', $post_id);
926 +
927 + return $ret;
928 + } // function feedwordpress_save_edit_controls
929 +
754 930 ################################################################################
755 931 ## class FeedWordPress #########################################################
756 932 ################################################################################
757 933
@@ -789,18 +965,82 @@
789 965 array('script', 'src')
790 966 );
791 967
792 968 var $feeds = NULL;
969 + var $feedurls = NULL;
970 + var $httpauth = NULL;
793 971
794 - # function FeedWordPress (): Contructor; retrieve a list of feeds
795 - function FeedWordPress () {
972 + /**
973 + * FeedWordPress::__construct (): Construct FeedWordPress singleton object
974 + * and retrieves a list of feeds for later reference.
975 + */
976 + public function __construct () {
796 977 $this->feeds = array ();
978 + $this->feedurls = array();
797 979 $links = FeedWordPress::syndicated_links();
798 980 if ($links): foreach ($links as $link):
799 - $this->feeds[] =& new SyndicatedLink($link);
981 + $id = intval($link->link_id);
982 + $url = $link->link_rss;
983 +
984 + // Store for later reference.
985 + $this->feeds[$id] = $id;
986 + if (strlen($url) > 0) :
987 + $this->feedurls[$url] = $id;
988 + endif;
800 989 endforeach; endif;
801 - } // FeedWordPress::FeedWordPress ()
802 990
991 + add_filter('feedwordpress_update_complete', array($this, 'process_retirements'), 1000, 1);
992 +
993 + $this->httpauth = new FeedWordPressHTTPAuthenticator;
994 + } /* FeedWordPress::__construct () */
995 +
996 + /**
997 + * FeedWordPress::subscribed (): Check whether a feed is currently in the
998 + * subscription list for FeedWordPress.
999 + *
1000 + * @param mixed $id Numeric ID of a WordPress link object or URL of a feed
1001 + * @return bool TRUE if currently subscribed; FALSE otherwise.
1002 + */
1003 + public function subscribed ($id) {
1004 + return (isset($this->feedurls[$id]) or isset($this->feeds[$id]));
1005 + } /* FeedWordPress::subscribed () */
1006 +
1007 + /**
1008 + * FeedWordPress::subscription (): Get the SyndicatedLink object for a
1009 + * given URL or numeric ID, if we have either an active subscription to
1010 + * it; or a de-activated subscription.
1011 + *
1012 + * @param mixed $which Numeric ID for a WordPress link object or string URL for a feed
1013 + * @return mixed SyndicatedLink object if subscription is found; NULL if not
1014 + */
1015 + public function subscription ($which) {
1016 + $sub = NULL;
1017 +
1018 + if (is_string($which) and isset($this->feedurls[$which])) :
1019 + $which = $this->feedurls[$which];
1020 + endif;
1021 +
1022 + if (isset($this->feeds[$which])) :
1023 + $sub = $this->feeds[$which];
1024 + endif;
1025 +
1026 + // If it's not in the in-memory cache already, try to load it from DB.
1027 + // This is necessary to fill requests for subscriptions that we don't
1028 + // cache in memory, e.g. for deactivated feeds.
1029 + if (is_null($sub)) :
1030 + $sub = get_bookmark($which);
1031 + endif;
1032 +
1033 + // Load 'er up if you haven't already.
1034 + if (!is_null($sub) and !($sub InstanceOf SyndicatedLink)) :
1035 + $link = new SyndicatedLink($sub);
1036 + $this->feeds[$which] = $link;
1037 + $sub = $link;
1038 + endif;
1039 +
1040 + return $sub;
1041 + } /* FeedWordPress::subscription () */
1042 +
803 1043 # function update (): polls for updates on one or more Contributor feeds
804 1044 #
805 1045 # Arguments:
806 1046 # ----------
@@ -844,22 +1084,29 @@
844 1084 # module elements) or else from a randomly-generated time window
845 1085 # (between 30 minutes and 2 hours).
846 1086 #
847 1087 # * New posts from the polled feed are added to the WordPress store.
848 - #
1088 + #
849 1089 # * Updates to existing posts since the last poll are mirrored in the
850 1090 # WordPress store.
851 1091 #
852 - function update ($uri = null, $crash_ts = null) {
1092 + public function update ($uri = null, $crash_ts = null) {
853 1093 global $wpdb;
854 1094
855 1095 if (FeedWordPress::needs_upgrade()) : // Will make duplicate posts if we don't hold off
856 1096 return NULL;
857 1097 endif;
858 -
859 - if (!is_null($uri)) :
1098 +
1099 + if (!is_null($uri) and $uri != '*') :
860 1100 $uri = trim($uri);
861 1101 else : // Update all
1102 + if ($this->update_hooked) :
1103 + $diag = $this->update_hooked;
1104 + else :
1105 + $diag = 'Initiating a MANUAL check-in on the update schedule at '.date('r', time());
1106 + endif;
1107 + $this->diagnostic('update_schedule:check', $diag);
1108 +
862 1109 update_option('feedwordpress_last_update_all', time());
863 1110 endif;
864 1111
865 1112 do_action('feedwordpress_update', $uri);
@@ -864,24 +1111,43 @@
864 1111
865 1112 do_action('feedwordpress_update', $uri);
866 1113
867 1114 if (is_null($crash_ts)) :
868 - $crash_dt = (int) get_option('feedwordpress_update_time_limit');
869 - if ($crash_dt > 0) :
870 - $crash_ts = time() + $crash_dt;
871 - else :
872 - $crash_ts = NULL;
873 - endif;
1115 + $crash_ts = $this->crash_ts();
874 1116 endif;
875 -
1117 +
876 1118 // Randomize order for load balancing purposes
877 - $feed_set = $this->feeds;
1119 + $feed_set = array_keys($this->feeds);
878 1120 shuffle($feed_set);
879 1121
1122 + $updateWindow = (int) get_option('feedwordpress_update_window', DEFAULT_UPDATE_PERIOD) * 60 /* sec/min */;
1123 + $interval = (int) get_option('feedwordpress_freshness', FEEDWORDPRESS_FRESHNESS_INTERVAL);
1124 + $portion = max(
1125 + (int) ceil(count($feed_set) / ($updateWindow / $interval)),
1126 + 10
1127 + );
1128 +
1129 + $max_polls = apply_filters('feedwordpress_polls_per_update', get_option(
1130 + 'feedwordpress_polls_per_update', $portion
1131 + ), $uri);
1132 +
1133 + $feed_set = apply_filters('feedwordpress_update_feeds', $feed_set, $uri);
1134 +
1135 +
880 1136 // Loop through and check for new posts
881 - $delta = NULL;
882 - foreach ($feed_set as $feed) :
883 - if (!is_null($crash_ts) and (time() > $crash_ts)) : // Check whether we've exceeded the time limit
1137 + $delta = NULL; $remaining = $max_polls;
1138 + foreach ($feed_set as $feed_id) :
1139 +
1140 + $feed = $this->subscription($feed_id);
1141 +
1142 + // Has this process overstayed its welcome?
1143 + if (
1144 + // Over time limit?
1145 + (!is_null($crash_ts) and (time() > $crash_ts))
1146 +
1147 + // Over feed count?
1148 + or ($remaining == 0)
1149 + ) :
884 1150 break;
885 1151 endif;
886 1152
887 1153 $pinged_that = (is_null($uri) or ($uri=='*') or in_array($uri, array($feed->uri(), $feed->homepage())));
@@ -891,40 +1157,120 @@
891 1157 else :
892 1158 $timely = $feed->stale();
893 1159 endif;
894 1160
895 - if ($pinged_that and is_null($delta)) : // If at least one feed was hit for updating...
896 - $delta = array('new' => 0, 'updated' => 0); // ... don't return error condition
1161 + // If at least one feed was hit for updating...
1162 + if ($pinged_that and is_null($delta)) :
1163 + // ... don't return error condition
1164 + $delta = array('new' => 0, 'updated' => 0, 'stored' => 0);
897 1165 endif;
898 1166
899 1167 if ($pinged_that and $timely) :
1168 + $remaining = $remaining - 1;
1169 +
900 1170 do_action('feedwordpress_check_feed', $feed->settings);
901 1171 $start_ts = time();
902 1172 $added = $feed->poll($crash_ts);
903 1173 do_action('feedwordpress_check_feed_complete', $feed->settings, $added, time() - $start_ts);
904 1174
905 - if (isset($added['new'])) : $delta['new'] += $added['new']; endif;
906 - if (isset($added['updated'])) : $delta['updated'] += $added['updated']; endif;
1175 + if (is_array($added)) : // Success
1176 + foreach ($added as $key => $count) :
1177 + $delta[$key] += $added[$key];
1178 + endforeach;
1179 + endif;
907 1180 endif;
908 1181 endforeach;
909 1182
910 1183 do_action('feedwordpress_update_complete', $delta);
1184 + return $delta;
1185 + } /* FeedWordPress::update () */
911 1186
912 - return $delta;
913 - }
1187 + public function crash_ts ($default = NULL) {
1188 + $crash_dt = (int) get_option('feedwordpress_update_time_limit', 0);
1189 + if ($crash_dt > 0) :
1190 + $crash_ts = time() + $crash_dt;
1191 + else :
1192 + $crash_ts = $default;
1193 + endif;
1194 + return $crash_ts;
1195 + } /* FeedWordPress::crash_ts () */
914 1196
915 - function stale () {
916 - if (get_option('feedwordpress_automatic_updates')) :
1197 + public function secret_key () {
1198 + $secret = get_option('feedwordpress_secret_key', false);
1199 + if (!$secret) : // Generate random key.
1200 + $secret = substr(md5(uniqid(microtime())), 0, 6);
1201 + update_option('feedwordpress_secret_key', $secret);
1202 + endif;
1203 + return $secret;
1204 + } /* FeedWordPress::secret_key () */
1205 +
1206 + public function has_secret () {
1207 + return (MyPHP::request('feedwordpress_key')==$this->secret_key());
1208 + } /* FeedWordPress::has_secret () */
1209 +
1210 + var $update_hooked = NULL;
1211 + public function automatic_update_hook ($params = array()) {
1212 + $params = wp_parse_args($params, array( // Defaults
1213 + 'setting only' => false,
1214 + ));
1215 + $hook = get_option('feedwordpress_automatic_updates', NULL);
1216 + $method = 'FeedWordPress option';
1217 +
1218 + // Allow for forced behavior in testing.
1219 + if (
1220 + !$params['setting only']
1221 + and $this->has_secret()
1222 + and MyPHP::request('automatic_update')
1223 + ) :
1224 + $hook = MyPHP::request('automatic_update');
1225 + $method = 'URL parameter';
1226 + endif;
1227 +
1228 + $exact = $hook; // Before munging
1229 +
1230 + if (!!$hook) :
1231 + if ($hook == 'init' or $hook == 'wp_loaded') : // Re-map init to wp_loaded
1232 + $hook = ($params['setting only'] ? 'init' : 'wp_loaded');
1233 +
1234 + // Constrain possible values. If it's not an init or wp_loaded, it's a shutdown
1235 + else :
1236 + $hook = 'shutdown';
1237 + endif;
1238 + endif;
1239 +
1240 + if ($hook) :
1241 + $this->update_hooked = "Initiating an AUTOMATIC CHECK FOR UPDATES ON PAGE LOAD ".$hook." due to ".$method." = ".trim($this->val($exact));
1242 + endif;
1243 +
1244 + return $hook;
1245 + } /* FeedWordPress::automatic_update_hook () */
1246 +
1247 + public function last_update_all () {
1248 + $last = get_option('feedwordpress_last_update_all');
1249 + if ($this->has_secret() and MyPHP::request('automatic_update')) :
1250 + $last = 1; // A long, long time ago.
1251 + elseif ($this->has_secret() and MyPHP::request('last_update_all')) :
1252 + $last = MyPHP::request('last_update_all');
1253 + endif;
1254 + return $last;
1255 + } /* FeedWordPress::last_update_all () */
1256 +
1257 + public function force_update_all () {
1258 + return ($this->has_secret() and MyPHP::request('force_update_feeds'));
1259 + } /* FeedWordPress::force_update_all () */
1260 +
1261 + public function stale () {
1262 + if (!is_null($this->automatic_update_hook())) :
917 1263 // Do our best to avoid possible simultaneous
918 1264 // updates by getting up-to-the-minute settings.
919 -
920 - $last = get_option('feedwordpress_last_update_all');
921 -
1265 +
1266 + $last = $this->last_update_all();
1267 +
922 1268 // If we haven't updated all yet, give it a time window
923 1269 if (false === $last) :
924 1270 $ret = false;
925 1271 update_option('feedwordpress_last_update_all', time());
926 -
1272 +
927 1273 // Otherwise, check against freshness interval
928 1274 elseif (is_numeric($last)) : // Expect a timestamp
929 1275 $freshness = get_option('feedwordpress_freshness');
930 1276 if (false === $freshness) : // Use default
@@ -929,13 +1275,13 @@
929 1275 $freshness = get_option('feedwordpress_freshness');
930 1276 if (false === $freshness) : // Use default
931 1277 $freshness = FEEDWORDPRESS_FRESHNESS_INTERVAL;
932 1278 endif;
933 - $ret = ( (time() - $last) > $freshness);
1279 + $ret = ( (time() - $last) > $freshness );
934 1280
935 - // This should never happen.
1281 + // This should never happen.
936 1282 else :
937 - FeedWordPress::critical_bug('FeedWordPress::stale::last', $last, __LINE__);
1283 + FeedWordPress::critical_bug('FeedWordPress::stale::last', $last, __LINE__, __FILE__);
938 1284 endif;
939 1285
940 1286 else :
941 1287 $ret = false;
@@ -940,72 +1286,666 @@
940 1286 else :
941 1287 $ret = false;
942 1288 endif;
943 1289 return $ret;
944 - } // FeedWordPress::stale()
1290 + } /* FeedWordPress::stale() */
1291 +
1292 + static function admin_init () {
1293 + // WordPress 3.5+ compat: the WP devs are in the midst of removing Links from the WordPress core. Eventually we'll have to deal
1294 + // with the possible disappearance of the wp_links table as a whole; but in the meantime, we just need to turn on the interface
1295 + // element to avoid problems with user capabilities that presume the presence of the Links Manager in the admin UI.
1296 + if (!intval(get_option('link_manager_enabled', false))) :
1297 + update_option('link_manager_enabled', true);
1298 + endif;
1299 +
1300 + if (defined('FEEDWORDPRESS_PREPARE_TO_ZAP') and FEEDWORDPRESS_PREPARE_TO_ZAP) :
1301 + $post_id = FEEDWORDPRESS_PREPARE_TO_ZAP;
1302 + $sendback = wp_get_referer();
1303 + if (
1304 + ! $sendback
1305 + or strpos( $sendback, 'post.php' ) !== false
1306 + or strpos( $sendback, 'post-new.php' ) !== false
1307 + ) :
1308 + if ( 'attachment' == $post_type ) :
1309 + $sendback = admin_url( 'upload.php' );
1310 + else :
1311 + $sendback = admin_url( 'edit.php' );
1312 + $sendback .= ( ! empty( $post_type ) ) ? '?post_type=' . $post_type : '';
1313 + endif;
1314 + else :
1315 + $sendback = esc_url( remove_query_arg( array('trashed', 'untrashed', 'deleted', 'zapped', 'unzapped', 'ids'), $sendback ) );
1316 + endif;
1317 +
1318 + // Make sure we have a post corresponding to this ID.
1319 + $post = $post_type = $post_type_object = null;
1320 + if ( $post_id ) :
1321 + $post = get_post( $post_id );
1322 + endif;
1323 +
1324 + if ( $post ) :
1325 + $post_type = $post->post_type;
1326 + endif;
1327 + $p = get_post($post_id);
1328 +
1329 + if ( ! $post ) :
1330 + wp_die( __( 'The item you are trying to zap no longer exists.' ) );
1331 + endif;
1332 +
1333 + if ( ! current_user_can( 'delete_post', $post_id ) ) :
1334 + wp_die( __( 'You are not allowed to zap this item.' ) );
1335 + endif;
1336 +
1337 + if ( $user_id = wp_check_post_lock( $post_id ) ) :
1338 + $user = get_userdata( $user_id );
1339 + wp_die( sprintf( __( 'You cannot retire this item. %s is currently editing.' ), $user->display_name ) );
1340 + endif;
1341 +
1342 + if (MyPHP::request('fwp_post_delete')=='zap') :
1343 + FeedWordPress::diagnostic('syndicated_posts', 'Zapping existing post # '.$p->ID.' "'.$p->post_title.'" due to user request.');
1344 +
1345 + $old_status = $post->post_status;
1346 +
1347 + set_post_field('post_status', 'fwpzapped', $post_id);
1348 + wp_transition_post_status('fwpzapped', $old_status, $post);
1349 +
1350 + # Set up the post to have its content blanked on
1351 + # next update if you do not undo the zapping.
1352 + add_post_meta($post_id, '_feedwordpress_zapped_blank_me', 1, /*unique=*/ true);
1353 + add_post_meta($post_id, '_feedwordpress_zapped_blank_old_status', $old_status, /*unique=*/ true);
1354 +
1355 + wp_redirect( esc_url_raw( add_query_arg( array('zapped' => 1, 'ids' => $post_id), $sendback ) ) );
1356 +
1357 + else :
1358 + $old_status = get_post_meta($post_id, '_feedwordpress_zapped_blank_old_status', /*single=*/ true);
1359 +
1360 + set_post_field('post_status', $old_status, $post_id);
1361 + wp_transition_post_status($old_status, 'fwpzapped', $post);
1362 +
1363 + # O.K., make sure this post does not get blanked
1364 + delete_post_meta($post_id, '_feedwordpress_zapped_blank_me');
1365 + delete_post_meta($post_id, '_feedwordpress_zapped_blank_old_status');
1366 +
1367 + wp_redirect( esc_url_raw( add_query_arg( array('unzapped' => 1, 'ids' => $post_id), $sendback ) ) );
1368 +
1369 + endif;
1370 +
1371 + // Intercept, don't pass on.
1372 + exit;
1373 + endif;
1374 + } /* FeedWordPress::admin_init() */
1375 +
1376 + public function admin_api () {
1377 + // This sucks, but WordPress doesn't give us any other way to
1378 + // easily invoke a permanent-delete from a plugged in post
1379 + // actions link. So we create a magic parameter, and when this
1380 + // magic parameter is activated, the WordPress trashcan is
1381 + // temporarily de-activated.
1382 +
1383 + if (MyPHP::request('fwp_post_delete')=='nuke') :
1384 + // Get post ID #
1385 + $post_id = MyPHP::request('post');
1386 + if (!$post_id) :
1387 + $post_id = MyPHP::request('post_ID');
1388 + endif;
1389 +
1390 + // Make sure we've got the right nonce and all that.
1391 + check_admin_referer('delete-post_' . $post_id);
1392 +
1393 + // If so, disable the trashcan.
1394 + define('EMPTY_TRASH_DAYS', 0);
1395 +
1396 + elseif (MyPHP::request('fwp_post_delete')=='zap' OR MyPHP::request('fwp_post_delete') == 'unzap') :
1397 + // Get post ID #
1398 + $post_id = MyPHP::request('post');
1399 + if (!$post_id) :
1400 + $post_id = MyPHP::request('post_ID');
1401 + endif;
1402 +
1403 + // Make sure we've got the right nonce and all that
1404 + check_admin_referer('delete-post_' . $post_id);
1405 +
1406 + // If so, get ready to intercept the call a little
1407 + // further down the line.
1408 +
1409 + define('FEEDWORDPRESS_PREPARE_TO_ZAP', $post_id);
1410 +
1411 + endif;
1412 +
1413 + } /* FeedWordPress::admin_api () */
1414 +
1415 + public function all_admin_notices () {
1416 + if (MyPHP::request('zapped')) :
1417 + $n = intval(MyPHP::request('zapped'));
1418 +?>
1419 +<div id="message" class="updated"><p><?php print $n; ?> syndicated item<?php print ($n!=1?'s':''); ?> zapped. <strong>These items will not be re-syndicated.</strong> If this was a mistake, you must <strong>immediately</strong> Un-Zap them in the Zapped items section to avoid losing the data.</p></div>
1420 +<?php
1421 + endif;
1422 +
1423 + if (MyPHP::request('unzapped')) :
1424 + $n = intval(MyPHP::request('unzapped'));
1425 +?>
1426 +<div id="message" class="updated"><p><?php print $n; ?> syndicated item<?php print ($n!=1?'s':'') ?> un-zapped and restored to normal.</p></div>
1427 +<?php
1428 + endif;
1429 + } /* FeedWordPress::all_admin_notices () */
945 1430
946 - function update_requested () {
947 - return (
948 - isset($_REQUEST['update_feedwordpress'])
949 - and $_REQUEST['update_feedwordpress']
1431 + public function process_retirements ($delta) {
1432 + update_option('feedwordpress_process_zaps', 1);
1433 +
1434 + return $delta;
1435 + }
1436 +
1437 + public function feedwordpress_cleanup () {
1438 + if (get_option('feedwordpress_process_zaps', null)) :
1439 + $q = new WP_Query(array(
1440 + 'fields' => '_synfrom',
1441 + 'post_status' => 'fwpzapped',
1442 + 'ignore_sticky_posts' => true,
1443 + 'meta_key' => '_feedwordpress_zapped_blank_me',
1444 + 'meta_value' => 1,
1445 + ));
1446 +
1447 + if ($q->have_posts()) :
1448 + foreach ($q->posts as $p) :
1449 +
1450 + $post_id = $p->ID;
1451 + $revisions = wp_get_post_revisions($post_id, array("check_enabled" => false));
1452 +
1453 + # Now nuke the content of the post & its revisions
1454 + set_post_field('post_content', '', $post_id);
1455 + set_post_field('post_excerpt', '', $post_id);
1456 +
1457 + foreach ($revisions as $rev) :
1458 + set_post_field('post_content', '', $rev->ID);
1459 + set_post_field('post_excerpt', '', $rev->ID);
1460 + endforeach;
1461 +
1462 + # Un-tag it for blanking.
1463 + delete_post_meta($p->ID, '_feedwordpress_zapped_blank_me');
1464 +
1465 + # Don't remove old_status indicator. A later
1466 + # update from the feed may cause us to once
1467 + # again have some content so we can un-zap.
1468 +
1469 + endforeach;
1470 + endif;
1471 +
1472 + $q = new WP_Query(array(
1473 + 'fields' => '_synfrom',
1474 + 'post_status' => 'fwpzapped',
1475 + 'ignore_sticky_posts' => true,
1476 + 'meta_key' => '_feedwordpress_zapped_blank_me',
1477 + 'meta_value' => 2,
1478 + ));
1479 +
1480 + if ($q->have_posts()) :
1481 + foreach ($q->posts as $p) :
1482 + update_post_meta($p->ID, '_feedwordpress_zapped_blank_me', 1);
1483 + endforeach;
1484 + endif;
1485 +
1486 + update_option('feedwordpress_process_zaps', 0);
1487 + endif;
1488 + } /* FeedWordPress::feedwordpress_cleanup () */
1489 +
1490 + public function init () {
1491 + global $fwp_path;
1492 +
1493 + // If this is a FeedWordPress admin page, queue up scripts for AJAX
1494 + // functions that FWP uses. If it is a display page or a non-FWP admin
1495 + // page, don't.
1496 + wp_register_style('feedwordpress-elements', plugins_url( '/'.$fwp_path.'/feedwordpress-elements.css') );
1497 + if (FeedWordPressSettingsUI::is_admin()) :
1498 + // For JavaScript that needs to be generated dynamically
1499 + add_action('admin_print_scripts', array('FeedWordPressSettingsUI', 'admin_scripts'));
1500 +
1501 + // For CSS that needs to be generated dynamically.
1502 + add_action('admin_print_styles', array('FeedWordPressSettingsUI', 'admin_styles'));
1503 +
1504 + wp_enqueue_style('dashboard');
1505 + wp_enqueue_style('feedwordpress-elements');
1506 +
1507 + /*if (function_exists('wp_admin_css')) :
1508 + wp_admin_css('css/dashboard');
1509 + endif;*/
1510 + endif;
1511 +
1512 + // These are a special post statuses for hiding posts that have
1513 + // expired from the feed or been marked for permanent zapping by
1514 + // the FWP admin.
1515 + register_post_status('fwpretired', array(
1516 + 'label' => _x('Retired', 'post'),
1517 + 'label_count' => _n_noop('Retired <span class="count">(%s)</span>', 'Retired <span class="count">(%s)</span>'),
1518 + 'exclude_from_search' => true,
1519 + 'public' => false,
1520 + 'publicly_queryable' => false,
1521 + 'show_in_admin_all_list' => false,
1522 + 'show_in_admin_status_list' => true,
1523 + ));
1524 + register_post_status('fwpzapped', array(
1525 + 'label' => _x('Zapped', 'post'),
1526 + 'label_count' => _n_noop('Zapped <span class="count">(%s)</span>', 'Retired <span class="count">(%s)</span>'),
1527 + 'exclude_from_search' => true,
1528 + 'public' => false,
1529 + 'publicly_queryable' => false,
1530 + 'show_in_admin_all_list' => false,
1531 + 'show_in_admin_status_list' => true,
1532 + ));
1533 + add_action(
1534 + /*hook=*/ 'template_redirect',
1535 + /*function=*/ array($this, 'redirect_retired'),
1536 + /*priority=*/ -100
950 1537 );
951 - } // FeedWordPress::update_requested()
952 1538
953 - function update_requested_url () {
954 - $ret = null;
1539 + add_action('wp_ajax_fwp_feeds', array($this, 'fwp_feeds'));
1540 + add_action('wp_ajax_fwp_feedcontents', array($this, 'fwp_feedcontents'));
1541 + add_action('wp_ajax_fwp_xpathtest', array($this, 'fwp_xpathtest'));
1542 +
1543 + } /* FeedWordPress::init() */
1544 +
1545 + /**
1546 + * FeedWordPress::wp_loaded (): Once all plugin and theme modules have been
1547 + * loaded and initialized (by actions on the init hook, etc.), check the HTTP
1548 + * request to see if we need to perform any special FeedWordPress-related
1549 + * actions.
1550 + *
1551 + * @since 2016.0614
1552 + */
1553 + public function wp_loaded () {
1554 + $this->clear_cache_magic_url();
1555 + $this->update_magic_url();
1556 + } /* FeedWordPress::wp_loaded () */
1557 +
1558 + public function fwp_feeds () {
1559 + $feeds = array();
1560 + $feed_ids = $this->feeds;
1561 +
1562 + foreach ($feed_ids as $id) :
1563 + $sub = $this->subscription($id);
1564 + $feeds[] = array(
1565 + "id" => $id,
1566 + "url" => $sub->uri(),
1567 + "name" => $sub->name(/*fromFeed=*/ false),
1568 + );
1569 + endforeach;
1570 +
1571 + header("Content-Type: application/json");
1572 + echo json_encode($feeds);
1573 + exit;
1574 + } /* FeedWordPress::fwp_feeds () */
1575 +
1576 + public function fwp_feedcontents () {
1577 + $feed_id = MyPHP::request('feed_id');
1578 +
1579 + // Let's load up some data from the feed . . .
1580 + $feed = $this->subscription($feed_id);
1581 + $posts = $feed->live_posts();
1582 +
1583 + if (is_wp_error($posts)) :
1584 + header("HTTP/1.1 502 Bad Gateway");
1585 + $result = $posts;
1586 + else :
1587 + $result = array();
1588 +
1589 + foreach ($posts as $post) :
1590 + $p = new SyndicatedPost($post, $feed);
1591 +
1592 + $result[] = array(
1593 + "post_title" => $p->entry->get_title(),
1594 + "post_link" => $p->permalink(),
1595 + "guid" => $p->guid(),
1596 + "post_date" => $p->published(),
1597 + );
1598 + endforeach;
1599 + endif;
1600 +
1601 + header("Content-Type: application/json");
1602 +
1603 + echo json_encode($result);
1604 +
1605 + // This is an AJAX request, so close it out thus.
1606 + die;
1607 + } /* FeedWordPress::fwp_feedcontents () */
1608 +
1609 + public function fwp_xpathtest () {
1610 + $xpath = MyPHP::request('xpath');
1611 + $feed_id = MyPHP::request('feed_id');
1612 + $post_id = MyPHP::request('post_id');
1613 +
1614 + $expr = new FeedWordPressParsedPostMeta($xpath);
1615 +
1616 + // Let's load up some data from the feed . . .
1617 + $feed = $this->subscription($feed_id);
1618 + $posts = $feed->live_posts();
1619 +
1620 + if (!is_wp_error($posts)) :
1621 + if (strlen($post_id) == 0) :
1622 + $post = $posts[0];
1623 + else :
1624 + $post = null;
1625 +
1626 + foreach ($posts as $p) :
1627 + if ($p->get_id() == $post_id) :
1628 + $post = $p;
1629 + endif;
1630 + endforeach;
1631 + endif;
1632 +
1633 + $post = new SyndicatedPost($post, $feed);
1634 + $meta = $expr->do_substitutions($post);
1635 +
1636 + $result = array(
1637 + "post_title" => $post->entry->get_title(),
1638 + "post_link" => $post->permalink(),
1639 + "guid" => $post->guid(),
1640 + "expression" => $xpath,
1641 + "results" => $meta
1642 + );
1643 + else :
1644 + $result = array(
1645 + "expression" => $xpath,
1646 + "feed_id" => $feed_id,
1647 + "post_id" => $post_id,
1648 + "results" => $posts
1649 + );
1650 +
1651 + header("HTTP/1.1 503 Bad Gateway");
1652 + endif;
1653 +
1654 + header("Content-Type: application/json");
1655 +
1656 + echo json_encode($result);
1657 +
1658 + // This is an AJAX request, so close it out thus.
1659 + die;
1660 + } /* FeedWordPress::fwp_xpathtest () */
1661 +
1662 + public function redirect_retired () {
1663 + global $wp_query;
1664 + if (is_singular()) :
1665 + if (
1666 + 'fwpretired'==$wp_query->post->post_status
1667 + or 'fwpzapped'==$wp_query->post->post_status
1668 + ) :
1669 + do_action('feedwordpress_redirect_retired', $wp_query->post);
1670 +
1671 + if (!($template = get_404_template())) :
1672 + $template = get_index_template();
1673 + endif;
1674 + if ($template = apply_filters('template_include', $template)) :
1675 + header("HTTP/1.1 410 Gone");
1676 + include($template);
1677 + endif;
1678 + exit;
1679 + endif;
1680 + endif;
1681 + } /* FeedWordPress::redirect_retired () */
1682 +
1683 + public function row_actions ($actions, $post) {
1684 + if (is_syndicated($post->ID) && current_user_can('edit_post', $post->ID)) :
1685 + $link = get_delete_post_link($post->ID, '', true);
1686 + $eraseLink = MyPHP::url($link, array("fwp_post_delete" => "nuke"));
1687 +
1688 + $caption = apply_filters('feedwordpress_ui_erase_link_caption', __('Erase the record of this post (will be re-syndicated if it still appears on the feed).'));
1689 + $linktext = apply_filters('feedwordpress_ui_erase_link_text', __('Erase/Resyndicate'));
955 1690
956 - if (($_REQUEST['update_feedwordpress']=='*')
957 - or (preg_match('|^http://.*|i', $_REQUEST['update_feedwordpress']))) :
958 - $ret = $_REQUEST['update_feedwordpress'];
1691 + $retireClass = NULL;
1692 + if ($post->post_status == 'fwpzapped') :
1693 + if (count(get_post_meta($post->ID, '_feedwordpress_zapped_blank_me')) > 0) :
1694 + $retireCap = 'Un-Zap this syndicated post (so it will appear on the site again)';
1695 + $retireText = 'Un-Zap &amp; Restore';
1696 + $retireLink = MyPHP::url($link, array("fwp_post_delete" => "unzap"));
1697 + else :
1698 + // No Un-Zap link for posts that have
1699 + // been blanked. You'll just have to
1700 + // Erase and hope you can resyndicate...
1701 + $retireLink = NULL;
1702 + endif;
1703 + else :
1704 + $retireCap = apply_filters('feedwordpress_ui_zap_link_caption', __('Zap this syndicated post (so it will not be re-syndicated if it still appears on the feed).'));
1705 + $retireText = apply_filters('feedwordpress_ui_zap_link_text', __('Zap/Don&#8217;t Resyndicate'));
1706 + $retireLink = MyPHP::url($link, array("fwp_post_delete" => "zap"));
1707 + $retireClass = 'submitdelete';
959 1708 endif;
1709 +
1710 + $keys = array_keys($actions);
1711 + $links = array();
1712 + foreach ($keys as $key) :
1713 + $links[$key] = $actions[$key];
960 1714
961 - return $ret;
962 - } // FeedWordPress::update_requested_url()
1715 + if ('trash'==$key) :
1716 + #$links[$key] = "<a class='submitdelete' title='" . esc_attr( __( 'Move this item to the Trash (will NOT be re-syndicated)' ) ) . "' href='" . get_delete_post_link( $post->ID ) . "'>" . __( 'Trash' ) . "</a>";
963 1717
964 - function syndicate_link ($name, $uri, $rss) {
1718 + // Placeholder.
1719 + if (!is_null($retireLink)) :
1720 + $links['zap trash'] = '';
1721 + endif;
1722 + $links['delete'] = '';
1723 + endif;
1724 + endforeach;
1725 +
1726 + if (!is_null($retireLink)) :
1727 + $links['zap trash'] = '<a class="'.esc_attr($retireClass).'" title="'.esc_attr(__($retireCap)).'" href="' . $retireLink . '">' . __($retireText) . '</a>';
1728 + endif;
1729 + $links['delete'] = '<a class="submitdelete" title="'.esc_attr(__($caption)).'" href="' . $eraseLink . '">' . __($linktext) . '</a>';
1730 +
1731 + $actions = $links;
1732 + endif;
1733 + return $actions;
1734 + } /* FeedWordPress::row_actions () */
1735 +
1736 + public function dashboard_setup () {
1737 + $see_it = FeedWordPress::menu_cap();
1738 +
1739 + if (current_user_can($see_it)) :
1740 + // Get the stylesheet
1741 + wp_enqueue_style('feedwordpress-elements');
1742 +
1743 + $widget_id = 'feedwordpress_dashboard';
1744 + $widget_name = __('Syndicated Sources');
1745 + $column = 'side';
1746 + $priority = 'core';
1747 +
1748 + // I would love to use wp_add_dashboard_widget() here and save
1749 + // myself some trouble. But WP 3 does not yet have any way to
1750 + // push a dashboard widget onto the side, or to give it a default
1751 + // location.
1752 + add_meta_box(
1753 + /*id=*/ $widget_id,
1754 + /*title=*/ $widget_name,
1755 + /*callback=*/ array($this, 'dashboard'),
1756 + /*page=*/ 'dashboard',
1757 + /*context=*/ $column,
1758 + /*priority=*/ $priority
1759 + );
1760 + /*control_callback= array($this, 'dashboard_control') */
1761 +
1762 + // This is kind of rude, I know, but the dashboard widget isn't
1763 + // worth much if users don't know that it exists, and I don't
1764 + // know of any better way to reorder the boxen.
1765 + //
1766 + // Gleefully ripped off of codex.wordpress.org/Dashboard_Widgets_API
1767 +
1768 + // Globalize the metaboxes array, this holds all the widgets for wp-admin
1769 + global $wp_meta_boxes;
1770 +
1771 + // Get the regular dashboard widgets array
1772 + // (which has our new widget already but at the end)
1773 +
1774 + $normal_dashboard = $wp_meta_boxes['dashboard'][$column][$priority];
1775 +
1776 + // Backup and delete our new dashbaord widget from the end of the array
1777 + if (isset($normal_dashboard[$widget_id])) :
1778 + $backup = array();
1779 + $backup[$widget_id] = $normal_dashboard[$widget_id];
1780 + unset($normal_dashboard[$widget_id]);
1781 +
1782 + // Merge the two arrays together so our widget is at the
1783 + // beginning
1784 + $sorted_dashboard = array_merge($backup, $normal_dashboard);
1785 +
1786 + // Save the sorted array back into the original metaboxes
1787 + $wp_meta_boxes['dashboard'][$column][$priority] = $sorted_dashboard;
1788 + endif;
1789 + endif;
1790 + } /* FeedWordPress::dashboard_setup () */
1791 +
1792 + public function dashboard () {
1793 + $syndicationPage = new FeedWordPressSyndicationPage(dirname(__FILE__).'/syndication.php');
1794 + $syndicationPage->dashboard_box($syndicationPage);
1795 + } /* FeedWordPress::dashboard () */
1796 +
1797 + public function user_can_richedit ($rich_edit) {
1798 +
1799 + $post = new FeedWordPressLocalPost;
1800 +
1801 + if (!$post->is_exposed_to_formatting_filters()) :
1802 + // Disable visual editor and only allow operations
1803 + // directly on HTML if post is bypassing fmt filters
1804 + # $rich_edit = false;
1805 + endif;
1806 +
1807 + return $rich_edit;
1808 +
1809 + } /* FeedWordPress::user_can_richedit () */
1810 +
1811 + public function clear_cache_magic_url () {
1812 + if ($this->clear_cache_requested()) :
1813 + $this->clear_cache();
1814 + endif;
1815 + } /* FeedWordPress::clear_cache_magic_url() */
1816 +
1817 + public function clear_cache_requested () {
1818 + return MyPHP::request('clear_cache');
1819 + } /* FeedWordPress::clear_cache_requested() */
1820 +
1821 + public function update_magic_url () {
965 1822 global $wpdb;
966 1823
1824 + // Explicit update request in the HTTP request (e.g. from a cron job)
1825 + if (self::update_requested()) :
1826 + /*DBG*/ header("Content-Type: text/plain");
1827 +
1828 + $this->update_hooked = "Initiating a CRON JOB CHECK-IN ON UPDATE SCHEDULE due to URL parameter = ".trim($this->val($_REQUEST['update_feedwordpress']));
1829 +
1830 + $this->update($this->update_requested_url());
1831 +
1832 + if (FEEDWORDPRESS_DEBUG and count($wpdb->queries) > 0) :
1833 + $mysqlTime = 0.0;
1834 + $byTime = array();
1835 + foreach ($wpdb->queries as $query) :
1836 + $time = $query[1] * 1000000.0;
1837 + $mysqlTime += $query[1];
1838 + if (!isset($byTime[$time])) : $byTime[$time] = array(); endif;
1839 + $byTime[$time][] = $query[0]. ' // STACK: ' . $query[2];
1840 + endforeach;
1841 + krsort($byTime);
1842 +
1843 + foreach ($byTime as $time => $querySet) :
1844 + foreach ($querySet as $query) :
1845 + print "[".(sprintf('%4.4f', $time/1000.0)) . "ms] $query\n";
1846 + endforeach;
1847 + endforeach;
1848 + echo self::log_prefix()."$wpdb->num_queries queries. $mysqlTime seconds in MySQL. Total of "; timer_stop(1); print " seconds.";
1849 + endif;
1850 +
1851 + debug_out_feedwordpress_footer();
1852 +
1853 + // Magic URL should return nothing but a 200 OK header packet
1854 + // when successful.
1855 + exit;
1856 + endif;
1857 + } /* FeedWordPress::update_magic_url () */
1858 +
1859 + public static function update_requested () {
1860 + return MyPHP::request('update_feedwordpress');
1861 + } /* FeedWordPress::update_requested() */
1862 +
1863 + public function update_requested_url () {
1864 + $ret = null;
1865 +
1866 + if (($_REQUEST['update_feedwordpress']=='*')
1867 + or (preg_match('|^[a-z]+://.*|i', $_REQUEST['update_feedwordpress']))) :
1868 + $ret = $_REQUEST['update_feedwordpress'];
1869 + endif;
1870 +
1871 + return $ret;
1872 + } /* FeedWordPress::update_requested_url() */
1873 +
1874 + public function auto_update () {
1875 + if ($this->stale()) :
1876 + $this->update();
1877 + endif;
1878 + } /* FeedWordPress::auto_update () */
1879 +
1880 + public static function find_link ($uri, $field = 'link_rss') {
1881 + global $wpdb;
1882 +
1883 + $unslashed = untrailingslashit($uri);
1884 + $slashed = trailingslashit($uri);
1885 + $link_id = $wpdb->get_var($wpdb->prepare("
1886 + SELECT link_id FROM $wpdb->links WHERE $field IN ('%s', '%s')
1887 + LIMIT 1", $unslashed, $slashed
1888 + ));
1889 +
1890 + return $link_id;
1891 + } /* FeedWordPress::find_link () */
1892 +
1893 + /**
1894 + * FeedWordPress:syndicate_link(): add or update a feed subscription
1895 + *
1896 + * Add a new subscription to, or update an existing subscription in,
1897 + * FWP's list of subscribed feeds.
1898 + *
1899 + * Postcondition: If $rss is the URL of a feed not yet on FWP's list of
1900 + * subscribed feeds, then a new subscription will be added, using $name
1901 + * as its initial title and $uri as its initial homepage URL (normally
1902 + * these will be updated with new values taken from the feed, the first
1903 + * time the new feed is checked for syndicated content, unless feed
1904 + * settings prevent this). If $rss is the URL of a feed that is already
1905 + * on FWP's list of subscribed feeds, then that feed will be updated to
1906 + * use the title provided in $name and the homepage URL in $uri
1907 + *
1908 + * @param string $name The human-readable title of the feed (for example, "Rad Geek People's Daily")
1909 + * @param string $uri The URI for the human-readable homepage associated with the feed (for example, <http://radgeek.com/>)
1910 + * @param string $rss The URI for the feed itself (for example, <http://radgeek.com/feed/>)
1911 + *
1912 + * @return mixed Returns an int with the numeric ID of the new
1913 + * subscription's wp_links record if successful or a WP_Error object
1914 + * if wp_insert_link() failed.
1915 + *
1916 + * @uses FeedWordPress::link_category_id()
1917 + * @uses FeedWordPress::find_link()
1918 + * @uses is_wp_error()
1919 + * @uses wp_insert_link()
1920 + *
1921 + */
1922 + public static function syndicate_link ($name, $uri, $rss) {
967 1923 // Get the category ID#
968 1924 $cat_id = FeedWordPress::link_category_id();
969 -
1925 + if (!is_wp_error($cat_id)) :
1926 + $link_category = array($cat_id);
1927 + else :
1928 + $link_category = array();
1929 + endif;
1930 +
970 1931 // WordPress gets cranky if there's no homepage URI
971 - if (!isset($uri) or strlen($uri)<1) : $uri = $rss; endif;
972 -
973 - if (function_exists('wp_insert_link')) : // WordPress 2.x
974 - if (FeedWordPressCompatibility::test_version(0, FWP_SCHEMA_21)) :
975 - // Morons.
976 - $name = $wpdb->escape($name);
977 - $uri = $wpdb->escape($uri);
978 - $rss = $wpdb->escape($rss);
979 -
980 - // Comes in as a single category
981 - $linkCats = $cat_id;
982 - else :
983 - // Comes in as an array of categories
984 - $linkCats = array($cat_id);
985 - endif;
1932 + if (!is_string($uri) or strlen($uri)<1) : $uri = $rss; endif;
986 1933
987 - $link_id = wp_insert_link(array(
988 - "link_name" => $name,
989 - "link_url" => $uri,
990 - "link_category" => $linkCats,
991 - "link_rss" => $rss
992 - ));
993 - else : // WordPress 1.5.x
994 - $result = $wpdb->query("
995 - INSERT INTO $wpdb->links
996 - SET
997 - link_name = '".$wpdb->escape($name)."',
998 - link_url = '".$wpdb->escape($uri)."',
999 - link_category = '".$wpdb->escape($cat_id)."',
1000 - link_rss = '".$wpdb->escape($rss)."'
1001 - ");
1002 - $link_id = $wpdb->insert_id;
1003 - endif;
1934 + // Check if this feed URL is already being syndicated.
1935 + $link_id = wp_insert_link(/*linkdata=*/ array(
1936 + "link_id" => FeedWordPress::find_link($rss), // insert if nothing was found; else update
1937 + "link_rss" => $rss,
1938 + "link_name" => $name,
1939 + "link_url" => $uri,
1940 + "link_category" => $link_category,
1941 + "link_visible" => 'Y', // reactivate if inactivated
1942 + ), /*wp_error=*/ true);
1943 +
1004 1944 return $link_id;
1005 - } // function FeedWordPress::syndicate_link()
1945 + } /* function FeedWordPress::syndicate_link() */
1006 1946
1007 - /*static*/ function syndicated_status ($what, $default) {
1947 + static function syndicated_status ($what, $default) {
1008 1948 $ret = get_option("feedwordpress_syndicated_{$what}_status");
1009 1949 if (!$ret) :
1010 1950 $ret = $default;
1011 1951 endif;
@@ -1011,29 +1951,19 @@
1011 1951 endif;
1012 1952 return $ret;
1013 1953 } /* FeedWordPress::syndicated_status() */
1014 1954
1015 - function on_unfamiliar ($what = 'author', $override = NULL) {
1016 - $set = array(
1017 - 'author' => array('create', 'default', 'filter'),
1018 - 'category' => array('create', 'tag', 'default', 'filter'),
1019 - );
1020 -
1021 - if (is_string($override)) :
1022 - $ret = strtolower($override);
1023 - endif;
1955 + public static function on_unfamiliar ($what = 'author') {
1956 + switch ($what) :
1957 + case 'category' : $suffix = ':category'; break;
1958 + case 'post_tag' : $suffix = ':post_tag'; break;
1959 + default: $suffix = '';
1960 + endswitch;
1024 1961
1025 - if (!is_numeric($override) and !in_array($ret, $set[$what])) :
1026 - $ret = get_option('feedwordpress_unfamiliar_'.$what);
1027 - if (!is_numeric($ret) and !in_array($ret, $set[$what])) :
1028 - $ret = 'create';
1029 - endif;
1030 - endif;
1031 -
1032 - return $ret;
1962 + return get_option('feedwordpress_unfamiliar_'.$what, 'create'.$suffix);
1033 1963 } // function FeedWordPress::on_unfamiliar()
1034 1964
1035 - function null_email_set () {
1965 + public static function null_email_set () {
1036 1966 $base = get_option('feedwordpress_null_email_set');
1037 1967
1038 1968 if ($base===false) :
1039 1969 $ret = array('noreply@blogger.com'); // default
@@ -1045,34 +1975,49 @@
1045 1975 return $ret;
1046 1976
1047 1977 } /* FeedWordPress::null_email_set () */
1048 1978
1049 - function is_null_email ($email) {
1979 + public static function is_null_email ($email) {
1050 1980 $ret = in_array(strtolower(trim($email)), FeedWordPress::null_email_set());
1051 1981 $ret = apply_filters('syndicated_item_author_is_null_email', $ret, $email);
1052 1982 return $ret;
1053 1983 } /* FeedWordPress::is_null_email () */
1054 1984
1055 - function use_aggregator_source_data () {
1985 + public static function use_aggregator_source_data () {
1056 1986 $ret = get_option('feedwordpress_use_aggregator_source_data');
1057 1987 return apply_filters('syndicated_post_use_aggregator_source_data', ($ret=='yes'));
1058 - }
1988 + } /* FeedWordPress::use_aggregator_source_data () */
1059 1989
1060 - function syndicated_links () {
1990 + /**
1991 + * FeedWordPress::munge_permalinks: check whether or not FeedWordPress
1992 + * should rewrite permalinks for syndicated items to reflect their
1993 + * original location.
1994 + *
1995 + * @return bool TRUE if FeedWordPress SHOULD rewrite permalinks; FALSE otherwise
1996 + */
1997 + static function munge_permalinks () {
1998 + return (get_option('feedwordpress_munge_permalink', /*default=*/ 'yes') != 'no');
1999 + } /* FeedWordPress::munge_permalinks() */
2000 +
2001 + public static function syndicated_links ($args = array()) {
1061 2002 $contributors = FeedWordPress::link_category_id();
1062 - if (function_exists('get_bookmarks')) :
1063 - $links = get_bookmarks(array("category" => $contributors));
1064 - else:
1065 - $links = get_linkobjects($contributors); // deprecated as of WP 2.1
2003 + if (!is_wp_error($contributors)) :
2004 + $links = get_bookmarks(array_merge(
2005 + array("category" => $contributors),
2006 + $args
2007 + ));
2008 + else :
2009 + $links = array();
1066 2010 endif;
2011 +
1067 2012 return $links;
1068 - } // function FeedWordPress::syndicated_links()
2013 + } /* FeedWordPress::syndicated_links() */
1069 2014
1070 - function link_category_id () {
2015 + public static function link_category_id () {
1071 2016 global $wpdb, $wp_db_version;
1072 2017
1073 2018 $cat_id = get_option('feedwordpress_cat_id');
1074 -
2019 +
1075 2020 // If we don't yet have the category ID stored, search by name
1076 2021 if (!$cat_id) :
1077 2022 $cat_id = FeedWordPressCompatibility::link_category_id(DEFAULT_SYNDICATION_CATEGORY);
1078 2023
@@ -1084,115 +2029,98 @@
1084 2029 // If we *do* have the category ID stored, verify that it exists
1085 2030 else :
1086 2031 $cat_id = FeedWordPressCompatibility::link_category_id((int) $cat_id, 'cat_id');
1087 2032 endif;
1088 -
2033 +
1089 2034 // If we could not find an appropriate link category,
1090 2035 // make a new one for ourselves.
1091 2036 if (!$cat_id) :
1092 2037 $cat_id = FeedWordPressCompatibility::insert_link_category(DEFAULT_SYNDICATION_CATEGORY);
1093 -
1094 - // Stamp it
1095 - update_option('feedwordpress_cat_id', $cat_id);
2038 + if (!is_wp_error($cat_id)) :
2039 + // Stamp it
2040 + update_option('feedwordpress_cat_id', $cat_id);
2041 + endif;
1096 2042 endif;
1097 2043
1098 2044 return $cat_id;
1099 - } // function FeedWordPress::link_category_id()
2045 + } /* FeedWordPress::link_category_id() */
1100 2046
1101 2047 # Upgrades and maintenance...
1102 - function needs_upgrade () {
2048 + static function needs_upgrade () {
2049 +
1103 2050 global $wpdb;
1104 - $fwp_db_version = get_option('feedwordpress_version');
2051 + $fwp_db_version = get_option('feedwordpress_version', NULL);
1105 2052 $ret = false; // innocent until proven guilty
1106 - if (!$fwp_db_version or $fwp_db_version < FEEDWORDPRESS_VERSION) :
1107 - // This is an older version or a fresh install. Does it
1108 - // require a database upgrade or database initialization?
1109 - if ($fwp_db_version <= 0.96) :
1110 - // Yes. Check to see whether this is a fresh install or an upgrade.
1111 - $syn = $wpdb->get_col("
1112 - SELECT post_id
1113 - FROM $wpdb->postmeta
1114 - WHERE meta_key = 'syndication_feed'
1115 - ");
1116 - if (count($syn) > 0) : // contains at least one syndicated post
1117 - $ret = true;
1118 - else : // fresh install; brand it as ours
1119 - update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
2053 + if (is_null($fwp_db_version) or ($fwp_db_version < FEEDWORDPRESS_VERSION)) :
2054 +
2055 + // This is an older version or a fresh install. Does it require a database
2056 + // upgrade or database initialization?
2057 +
2058 + if (is_null($fwp_db_version)) :
2059 +
2060 + // Fresh install; brand it as ours. Or possibly a version of FWP
2061 + // from before 0.96. But I'm no longer supporting upgrade paths
2062 + // for versions from the previous decade. Sorry.
2063 + update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
2064 +
2065 + elseif ($fwp_db_version < 2010.0814) :
2066 +
2067 + // Change in terminology.
2068 + if (get_option('feedwordpress_unfamiliar_category', 'create')=='default') :
2069 + update_option('feedwordpress_unfamiliar_category', 'null');
1120 2070 endif;
1121 - elseif ($fwp_db_version < 2009.0707) :
1122 - // We need to clear out any busted AJAX crap
1123 - if (fwp_test_wp_version(FWP_SCHEMA_HAS_USERMETA)) :
1124 - $wpdb->query("
1125 - DELETE FROM $wpdb->usermeta
1126 - WHERE LOCATE('feedwordpress', meta_key)
1127 - AND LOCATE('box', meta_key);
1128 - ");
1129 - endif;
2071 + foreach (FeedWordPress::syndicated_links() as $link) :
2072 + $sub = new SyndicatedLink($link);
2073 +
2074 + $remap_uf = array(
2075 + 'default' => 'null',
2076 + 'filter' => 'null',
2077 + 'create' => 'create:category',
2078 + 'tag' => 'create:post_tag'
2079 + );
2080 + if (isset($sub->settings['unfamiliar category'])) :
2081 + if ($sub->settings['unfamiliar category']=='filter') :
2082 + $sub->settings['match/filter'] = array('category');
2083 + endif;
2084 + foreach ($remap_uf as $from => $to) :
2085 + if ($sub->settings['unfamiliar category']==$from) :
2086 + $sub->settings['unfamiliar category'] = $to;
2087 + endif;
2088 + endforeach;
2089 + endif;
2090 +
2091 + if (isset($sub->settings['add global categories'])) :
2092 + $sub->settings['add/category'] = $sub->settings['add global categories'];
2093 + unset($sub->settings['add global categories']);
2094 + endif;
2095 +
2096 + $sub->save_settings(/*reload=*/ true);
2097 + endforeach;
1130 2098 update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
2099 +
1131 2100 else :
1132 - // No. Just brand it with the new version.
2101 +
2102 + // No upgrade needed. Just brand it with the new version.
1133 2103 update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
2104 +
1134 2105 endif;
2106 +
1135 2107 endif;
1136 2108 return $ret;
1137 - }
2109 + } /* FeedWordPress::needs_upgrade () */
1138 2110
1139 - function upgrade_database ($from = NULL) {
2111 + static function upgrade_database ($from = NULL) {
1140 2112 global $wpdb;
1141 2113
1142 2114 if (is_null($from) or $from <= 0.96) : $from = 0.96; endif;
1143 2115
1144 2116 switch ($from) :
1145 - case 0.96: // account for changes to syndication custom values and guid
1146 - echo "<p>Upgrading database from {$from} to ".FEEDWORDPRESS_VERSION."...</p>\n";
2117 + case 0.96:
2118 + // Dropping legacy upgrade code. If anyone is still
2119 + // using 0.96 and just now decided to upgrade, well, I'm
2120 + // sorry about that. You'll just have to cope with a few
2121 + // duplicate posts.
1147 2122
1148 - $cat_id = FeedWordPress::link_category_id();
1149 -
1150 - // Avoid duplicates
1151 - $wpdb->query("DELETE FROM `{$wpdb->postmeta}` WHERE meta_key = 'syndication_feed_id'");
1152 -
1153 - // Look up all the link IDs
1154 - $wpdb->query("
1155 - CREATE TEMPORARY TABLE tmp_custom_values
1156 - SELECT
1157 - NULL AS meta_id,
1158 - post_id,
1159 - 'syndication_feed_id' AS meta_key,
1160 - link_id AS meta_value
1161 - FROM `{$wpdb->postmeta}`, `{$wpdb->links}`
1162 - WHERE
1163 - meta_key='syndication_feed'
1164 - AND meta_value=link_rss
1165 - AND link_category = {$cat_id}
1166 - ");
1167 -
1168 - // Now attach them to their posts
1169 - $wpdb->query("INSERT INTO `{$wpdb->postmeta}` SELECT * FROM tmp_custom_values");
1170 -
1171 - // And clean up after ourselves.
1172 - $wpdb->query("DROP TABLE tmp_custom_values");
1173 -
1174 - // Now fix the guids to avoid duplicate posts
1175 - echo "<ul>";
1176 - foreach ($this->feeds as $syndicatedLink) :
1177 - $feed = $syndicatedLink->settings;
1178 - echo "<li>Fixing post meta-data for <cite>".$feed['link/name']."</cite> &#8230; "; flush();
1179 - $rss = @fetch_rss($feed['link/uri']);
1180 - if (is_array($rss->items)) :
1181 - foreach ($rss->items as $item) :
1182 - $post = new SyndicatedPost($item, $syndicatedLink);
1183 - $guid = $wpdb->escape($post->guid()); // new GUID algorithm
1184 - $link = $wpdb->escape($item['link']);
1185 -
1186 - $wpdb->query("
1187 - UPDATE `{$wpdb->posts}` SET guid='{$guid}' WHERE guid='{$link}'
1188 - ");
1189 - endforeach;
1190 - endif;
1191 - echo "<strong>complete.</strong></li>\n";
1192 - endforeach;
1193 - echo "</ul>\n";
1194 -
1195 2123 // Mark the upgrade as successful.
1196 2124 update_option('feedwordpress_version', FEEDWORDPRESS_VERSION);
1197 2125 endswitch;
1198 2126 echo "<p>Upgrade complete. FeedWordPress is now ready to use again.</p>";
@@ -1197,107 +2125,458 @@
1197 2125 endswitch;
1198 2126 echo "<p>Upgrade complete. FeedWordPress is now ready to use again.</p>";
1199 2127 } /* FeedWordPress::upgrade_database() */
1200 2128
1201 - function create_guid_index () {
2129 + public static function has_guid_index () {
1202 2130 global $wpdb;
1203 -
2131 +
2132 + $found = false; // Guilty until proven innocent.
2133 +
2134 + $results = $wpdb->get_results("
2135 + SHOW INDEXES FROM {$wpdb->posts}
2136 + ");
2137 + if ($results) :
2138 + foreach ($results as $index) :
2139 + if (isset($index->Column_name)
2140 + and ('guid' == $index->Column_name)) :
2141 + $found = true;
2142 + endif;
2143 + endforeach;
2144 + endif;
2145 + return $found;
2146 + } /* FeedWordPress::has_guid_index () */
2147 +
2148 + public static function create_guid_index () {
2149 + global $wpdb;
2150 +
1204 2151 $wpdb->query("
1205 2152 CREATE INDEX {$wpdb->posts}_guid_idx ON {$wpdb->posts}(guid)
1206 2153 ");
1207 2154 } /* FeedWordPress::create_guid_index () */
1208 -
1209 - function clear_cache () {
2155 +
2156 + public static function remove_guid_index () {
1210 2157 global $wpdb;
1211 -
1212 - // MagpieRSS stores its cached feeds in options table rows with
1213 - // name = `rss_{md5 of url}` and timestamps for cached feeds in
1214 - // table rows with name = `rss_{md5 of url}_ts`. The md5 is
1215 - // always 32 characters in length, so the total option_name is
1216 - // always over 32 characters.
2158 +
1217 2159 $wpdb->query("
2160 + DROP INDEX {$wpdb->posts}_guid_idx ON {$wpdb->posts}
2161 + ");
2162 + }
2163 +
2164 + static function fetch_timeout () {
2165 + return apply_filters(
2166 + 'feedwordpress_fetch_timeout',
2167 + intval(get_option('feedwordpress_fetch_timeout', FEEDWORDPRESS_FETCH_TIMEOUT_DEFAULT))
2168 + );
2169 + }
2170 +
2171 + static function fetch ($url, $params = array()) {
2172 + if (is_wp_error($url)) :
2173 + // Let's bounce.
2174 + return $url;
2175 + endif;
2176 +
2177 + $force_feed = true; // Default
2178 +
2179 + // Allow user to change default feed-fetch timeout with a global setting.
2180 + // Props Erigami Scholey-Fuller <http://www.piepalace.ca/blog/2010/11/feedwordpress-broke-my-heart.html>
2181 + $timeout = FeedWordPress::fetch_timeout();
2182 +
2183 + if (!is_array($params)) :
2184 + $force_feed = $params;
2185 + else : // Parameter array
2186 + $args = wp_parse_args(array(
2187 + 'force_feed' => $force_feed,
2188 + 'timeout' => $timeout
2189 + ), $params);
2190 +
2191 + extract($args);
2192 + endif;
2193 + $timeout = intval($timeout);
2194 +
2195 + $pie_class = apply_filters('feedwordpress_simplepie_class', 'FeedWordPie');
2196 + $cache_class = apply_filters('feedwordpress_cache_class', 'WP_Feed_Cache');
2197 + $file_class = apply_filters('feedwordpress_file_class', 'FeedWordPress_File');
2198 + $parser_class = apply_filters('feedwordpress_parser_class', 'FeedWordPress_Parser');
2199 + $item_class = apply_filters('feedwordpress_item_class', 'FeedWordPie_Item');
2200 + $sniffer_class = apply_filters('feedwordpress_sniffer_class', 'FeedWordPress_Content_Type_Sniffer');
2201 +
2202 + $feed = new $pie_class;
2203 + $feed->set_feed_url($url);
2204 + $feed->set_cache_class($cache_class);
2205 + $feed->set_timeout($timeout);
2206 +
2207 + $feed->set_content_type_sniffer_class($sniffer_class);
2208 + $feed->set_file_class($file_class);
2209 + $feed->set_parser_class($parser_class);
2210 + $feed->set_item_class($item_class);
2211 + $feed->force_feed($force_feed);
2212 + $feed->set_cache_duration(FeedWordPress::cache_duration($params));
2213 + $feed->init();
2214 + $feed->handle_content_type();
2215 +
2216 + if ($feed->error()) :
2217 + $ret = new WP_Error('simplepie-error', $feed->error());
2218 + else :
2219 + $ret = $feed;
2220 + endif;
2221 + return $ret;
2222 + } /* FeedWordPress::fetch () */
2223 +
2224 + public function clear_cache () {
2225 + global $wpdb;
2226 +
2227 + // Just in case, clear out any old MagpieRSS cache records.
2228 + $magpies = $wpdb->query("
1218 2229 DELETE FROM {$wpdb->options}
1219 - WHERE LOCATE('rss_', option_name) AND LENGTH(option_name) > 32
2230 + WHERE option_name LIKE 'rss_%' AND LENGTH(option_name) > 32
1220 2231 ");
2232 +
2233 + // The WordPress SimplePie module stores its cached feeds as
2234 + // transient records in the options table. The data itself is
2235 + // stored in `_transient_feed_{md5 of url}` and the last-modified
2236 + // timestamp in `_transient_feed_mod_{md5 of url}`. Timeouts for
2237 + // these records are stored in `_transient_timeout_feed_{md5}`.
2238 + // Since the md5 is always 32 characters in length, the
2239 + // option_name is always over 32 characters.
2240 + $simplepies = $wpdb->query("
2241 + DELETE FROM {$wpdb->options}
2242 + WHERE option_name LIKE '_transient%_feed_%' AND LENGTH(option_name) > 32
2243 + ");
2244 + $simplepies = (int) ($simplepies / 4); // Each transient has 4 rows: the data, the modified timestamp; and the timeouts for each
2245 +
2246 + return ($magpies + $simplepies);
1221 2247 } /* FeedWordPress::clear_cache () */
1222 2248
1223 - function magpie_version () {
1224 - if (!defined('MAGPIE_VERSION')) : $magpie_version = $GLOBALS['wp_version'].'-default';
1225 - else : $magpie_version = MAGPIE_VERSION;
2249 + static public function cache_duration ($params = array()) {
2250 + $params = wp_parse_args($params, array(
2251 + "cache" => true,
2252 + ));
2253 +
2254 + $duration = NULL;
2255 + if (!$params['cache']) :
2256 + $duration = 0;
2257 + elseif (defined('FEEDWORDPRESS_CACHE_AGE')) :
2258 + $duration = FEEDWORDPRESS_CACHE_AGE;
1226 2259 endif;
1227 - return $magpie_version;
2260 + return $duration;
1228 2261 }
1229 2262
2263 + static public function cache_lifetime ($duration) {
2264 + // Check for explicit setting of a lifetime duration
2265 + if (defined('FEEDWORDPRESS_CACHE_LIFETIME')) :
2266 + $duration = FEEDWORDPRESS_CACHE_LIFETIME;
2267 +
2268 + // Fall back to the cache freshness duration
2269 + elseif (defined('FEEDWORDPRESS_CACHE_AGE')) :
2270 + $duration = FEEDWORDPRESS_CACHE_AGE;
2271 + endif;
2272 +
2273 + // Fall back to WordPress default
2274 + return $duration;
2275 + } /* FeedWordPress::cache_lifetime () */
2276 +
1230 2277 # Utility functions for handling text settings
1231 - function negative ($f, $setting) {
2278 + static function negative ($f, $setting) {
1232 2279 $nego = array ('n', 'no', 'f', 'false');
1233 2280 return (isset($f[$setting]) and in_array(strtolower($f[$setting]), $nego));
1234 - }
2281 + } /* FeedWordPress::negative () */
1235 2282
1236 - function affirmative ($f, $setting) {
2283 + static function affirmative ($f, $setting) {
1237 2284 $affirmo = array ('y', 'yes', 't', 'true', 1);
1238 2285 return (isset($f[$setting]) and in_array(strtolower($f[$setting]), $affirmo));
1239 - }
2286 + } /* FeedWordPress::affirmative () */
1240 2287
1241 -
1242 2288 # Internal debugging functions
1243 - function critical_bug ($varname, $var, $line) {
2289 + static function critical_bug ($varname, $var, $line, $file = NULL) {
1244 2290 global $wp_version;
1245 2291
1246 - if (defined('MAGPIE_VERSION')) : $mv = MAGPIE_VERSION;
1247 - else : $mv = 'WordPress '.$wp_version.' default.';
2292 + if (!is_null($file)) :
2293 + $location = "line # ${line} of ".basename($file);
2294 + else :
2295 + $location = "line # ${line}";
1248 2296 endif;
1249 2297
1250 - echo '<p>There may be a bug in FeedWordPress. Please <a href="'.FEEDWORDPRESS_AUTHOR_CONTACT.'">contact the author</a> and paste the following information into your e-mail:</p>';
1251 - echo "\n<plaintext>";
1252 - echo "Triggered at line # ".$line."\n";
1253 - echo "FeedWordPress version: ".FEEDWORDPRESS_VERSION."\n";
1254 - echo "MagpieRSS version: {$mv}\n";
1255 - echo "WordPress version: {$wp_version}\n";
1256 - echo "PHP version: ".phpversion()."\n";
1257 - echo "\n";
1258 - echo $varname.": "; var_dump($var); echo "\n";
2298 + print '<p><strong>Critical error:</strong> There may be a bug in FeedWordPress. Please <a href="'.FEEDWORDPRESS_AUTHOR_CONTACT.'">contact the author</a> and paste the following information into your e-mail:</p>';
2299 + print "\n<plaintext>";
2300 + print "Triggered at ${location}\n";
2301 + print "FeedWordPress: ".FEEDWORDPRESS_VERSION."\n";
2302 + print "WordPress: {$wp_version}\n";
2303 + print "PHP: ".phpversion()."\n";
2304 + print "Error data: ";
2305 + print $varname.": "; var_dump($var); echo "\n";
1259 2306 die;
1260 - }
1261 -
1262 - function noncritical_bug ($varname, $var, $line) {
2307 + } /* FeedWordPress::critical_bug () */
2308 +
2309 + static function noncritical_bug ($varname, $var, $line, $file = NULL) {
1263 2310 if (FEEDWORDPRESS_DEBUG) : // halt only when we are doing debugging
1264 - FeedWordPress::critical_bug($varname, $var, $line);
2311 + FeedWordPress::critical_bug($varname, $var, $line, $file);
1265 2312 endif;
1266 - }
1267 -} // class FeedWordPress
2313 + } /* FeedWordPress::noncritical_bug () */
1268 2314
1269 -require_once(dirname(__FILE__) . '/syndicatedpost.class.php');
1270 -require_once(dirname(__FILE__) . '/syndicatedlink.class.php');
2315 + static function val ($v, $no_newlines = false) {
2316 + return MyPHP::val($v, $no_newlines);
2317 + } /* FeedWordPress::val () */
1271 2318
1272 -################################################################################
1273 -## XML-RPC HOOKS: accept XML-RPC update pings from Contributors ################
1274 -################################################################################
2319 + static function diagnostic_on ($level) {
2320 + $show = get_option('feedwordpress_diagnostics_show', array());
2321 + return (in_array($level, $show));
2322 + } /* FeedWordPress::diagnostic_on () */
1275 2323
1276 -function feedwordpress_xmlrpc_hook ($args = array ()) {
1277 - $args['weblogUpdates.ping'] = 'feedwordpress_pong';
1278 - return $args;
1279 -}
2324 + static function diagnostic ($level, $out, $persist = NULL, $since = NULL, $mostRecent = NULL) {
2325 + global $feedwordpress_admin_footer;
1280 2326
1281 -function feedwordpress_pong ($args) {
1282 - $feedwordpress =& new FeedWordPress;
1283 - $delta = @$feedwordpress->update($args[1]);
1284 - if (is_null($delta)):
1285 - return array('flerror' => true, 'message' => "Sorry. I don't syndicate <$args[1]>.");
1286 - else:
1287 - $mesg = array();
1288 - if (isset($delta['new'])) { $mesg[] = ' '.$delta['new'].' new posts were syndicated'; }
1289 - if (isset($delta['updated'])) { $mesg[] = ' '.$delta['updated'].' existing posts were updated'; }
2327 + $output = get_option('feedwordpress_diagnostics_output', array());
2328 + $dlog = get_option('feedwordpress_diagnostics_log', array());
1290 2329
1291 - return array('flerror' => false, 'message' => "Thanks for the ping.".implode(' and', $mesg));
1292 - endif;
1293 -}
2330 + $diagnostic_nesting = count(explode(":", $level));
1294 2331
1295 -# The upgraded MagpieRSS also uses this class. So if we have it loaded
1296 -# in, don't load it again.
1297 -if (!class_exists('Relative_URI')) {
1298 - require_once(dirname(__FILE__) . '/relative_uri.class.php');
1299 -}
2332 + if (self::diagnostic_on($level)) :
2333 + foreach ($output as $method) :
2334 + switch ($method) :
2335 + case 'echo' :
2336 + if (!self::update_requested()) :
2337 + echo "<div><pre><strong>Diag".str_repeat('====', $diagnostic_nesting-1).'|</strong> '.$out."</pre></div>\n";
2338 + endif;
2339 + break;
2340 + case 'echo_in_cronjob' :
2341 + if (self::update_requested()) :
2342 + echo self::log_prefix()." ".$out."\n";
2343 + endif;
2344 + break;
2345 + case 'admin_footer' :
2346 + $feedwordpress_admin_footer[] = $out;
2347 + break;
2348 + case 'error_log' :
2349 + error_log(self::log_prefix().' '.$out);
2350 + break;
2351 + case 'email' :
2352 +
2353 + if (is_null($persist)) :
2354 + $sect = 'occurrent';
2355 + $hook = (isset($dlog['mesg'][$sect]) ? count($dlog['mesg'][$sect]) : 0);
2356 + $line = array("Time" => time(), "Message" => $out);
2357 + else :
2358 + $sect = 'persistent';
2359 + $hook = md5($level."\n".$persist);
2360 + $line = array("Since" => $since, "Message" => $out, "Most Recent" => $mostRecent);
2361 + endif;
2362 +
2363 + if (!isset($dlog['mesg'])) : $dlog['mesg'] = array(); endif;
2364 + if (!isset($dlog['mesg'][$sect])) : $dlog['mesg'][$sect] = array(); endif;
2365 +
2366 + $dlog['mesg'][$sect][$hook] = $line;
2367 + endswitch;
2368 + endforeach;
2369 + endif;
2370 +
2371 + update_option('feedwordpress_diagnostics_log', $dlog);
2372 + } /* FeedWordPress::diagnostic () */
2373 +
2374 + public function email_diagnostics_override () {
2375 + return ($this->has_secret() and isset($_REQUEST['feedwordpress_email_diagnostics']) and !!$_REQUEST['feedwordpress_email_diagnostics']);
2376 + } /* FeedWordPress::email_diagnostics_override () */
2377 +
2378 + public function has_emailed_diagnostics ($dlog) {
2379 + $ret = false;
2380 + if ($this->email_diagnostics_override()
2381 + or (isset($dlog['schedule']) and isset($dlog['schedule']['last']))) :
2382 + $ret = true;
2383 + endif;
2384 + return $ret;
2385 + } /* FeedWordPress::has_emailed_diagnostics () */
2386 +
2387 + public function ready_to_email_diagnostics ($dlog) {
2388 + $ret = false;
2389 + if ($this->email_diagnostics_override()
2390 + or (time() > ($dlog['schedule']['last'] + $dlog['schedule']['freq']))) :
2391 + $ret = true;
2392 + endif;
2393 + return $ret;
2394 + } /* FeedWordPress::ready_to_email_diagnostics () */
2395 +
2396 + public function email_diagnostic_log ($params = array()) {
2397 + $params = wp_parse_args($params, array(
2398 + "force" => false,
2399 + ));
2400 +
2401 + $dlog = get_option('feedwordpress_diagnostics_log', array());
2402 +
2403 + if ($this->has_emailed_diagnostics($dlog)) :
2404 + if ($this->ready_to_email_diagnostics($dlog)) :
2405 + // No news is good news; only send if
2406 + // there are some messages to send.
2407 + $body = NULL;
2408 + if (!isset($dlog['mesg'])) : $dlog['mesg'] = array(); endif;
2409 +
2410 + foreach ($dlog['mesg'] as $sect => $mesgs) :
2411 + if (count($mesgs) > 0) :
2412 + if (is_null($body)) : $body = ''; endif;
2413 +
2414 + $paradigm = reset($mesgs);
2415 + $body .= "<h2>".ucfirst($sect)." issues</h2>\n"
2416 + ."<table>\n"
2417 + ."<thead><tr>\n";
2418 + foreach ($paradigm as $col => $value) :
2419 + $body .= '<th scope="col">'.$col."</th>\n";
2420 + endforeach;
2421 + $body .= "</tr></thead>\n"
2422 + ."<tbody>\n";
2423 +
2424 + foreach ($mesgs as $line) :
2425 + $body .= "<tr>\n";
2426 + foreach ($line as $col => $cell) :
2427 + if (is_numeric($cell)) :
2428 + $cell = date('j-M-y, h:i a', $cell);
2429 + endif;
2430 + $class = strtolower(preg_replace('/\s+/', '-', $col));
2431 + $body .= "<td class=\"$class\">${cell}</td>";
2432 + endforeach;
2433 + $body .= "</tr>\n";
2434 + endforeach;
2435 +
2436 + $body .= "</tbody>\n</table>\n\n";
2437 + endif;
2438 + endforeach;
2439 +
2440 + $body = apply_filters('feedwordpress_diagnostic_email_body', $body, $dlog);
2441 + if (!is_null($body)) :
2442 + $home = feedwordpress_display_url(get_bloginfo('url'));
2443 + $subj = apply_filters('feedwordpress_diagnostic_email_subject', $home . " syndication issues", $dlog);
2444 + $agent = 'FeedWordPress '.FEEDWORDPRESS_VERSION;
2445 + $body = <<<EOMAIL
2446 +<html>
2447 +<head>
2448 +<title>$subj</title>
2449 +<style type="text/css">
2450 + body { background-color: white; color: black; }
2451 + table { width: 100%; border: 1px solid black; }
2452 + table thead tr th { background-color: #ff7700; color: white; border-bottom: 1px solid black; }
2453 + table thead tr { border-bottom: 1px solid black; }
2454 + table tr { vertical-align: top; }
2455 + table .since { width: 20%; }
2456 + table .time { width: 20%; }
2457 + table .most-recently { width: 20%; }
2458 + table .message { width: auto; }
2459 +</style>
2460 +</head>
2461 +<body>
2462 +<h1>Syndication Issues encountered by $agent on $home</h1>
2463 +$body
2464 +</body>
2465 +</html>
2466 +
2467 +EOMAIL;
2468 +
2469 + $ded = get_option('feedwordpress_diagnostics_email_destination', 'admins');
2470 +
2471 + // e-mail address
2472 + if (preg_match('/^mailto:(.*)$/', $ded, $ref)) :
2473 + $recipients = array($ref[1]);
2474 +
2475 + // userid
2476 + elseif (preg_match('/^user:(.*)$/', $ded, $ref)) :
2477 + $userdata = get_userdata((int) $ref[1]);
2478 + $recipients = array($userdata->user_email);
2479 +
2480 + // admins
2481 + else :
2482 + $recipients = FeedWordPressDiagnostic::admin_emails();
2483 + endif;
2484 +
2485 + $mesgId = 'feedwordpress+'.time().'@'.$home;
2486 + $parentId = get_option('feedwordpress_diagnostics_email_root_message_id', NULL);
2487 +
2488 + $head = array("Message-ID: <$mesgId>");
2489 + if (!is_null($parentId)) :
2490 + // We've already sent off a diagnostic message in the past. Let's do some
2491 + // magic to help with threading, in the hopes that all diagnostic messages
2492 + // get threaded together.
2493 + $head[] = "References: <$parentId>";
2494 + $head[] = "In-Reply-To: <$parentId>";
2495 + $subj = "Re: ".$subj;
2496 + else :
2497 + // This is the first of its kind. Let's mark it as such.
2498 + update_option('feedwordpress_diagnostics_email_root_message_id', $mesgId);
2499 + endif;
2500 + $head = apply_filters('feedwordpress_diagnostic_email_headers', $head);
2501 +
2502 + foreach ($recipients as $email) :
2503 + add_filter('wp_mail_content_type', array('FeedWordPress', 'allow_html_mail'));
2504 + wp_mail($email, $subj, $body, $head);
2505 + remove_filter('wp_mail_content_type', array('FeedWordPress', 'allow_html_mail'));
2506 + endforeach;
2507 + endif;
2508 +
2509 + // Clear the logs
2510 + $dlog['mesg']['persistent'] = array();
2511 + $dlog['mesg']['occurrent'] = array();
2512 +
2513 + // Set schedule for next update
2514 + $dlog['schedule']['last'] = time();
2515 + endif;
2516 + else :
2517 + $dlog['schedule'] = array(
2518 + 'freq' => 24 /*hr*/ * 60 /*min*/ * 60 /*s*/,
2519 + 'last' => time(),
2520 + );
2521 + endif;
2522 +
2523 + update_option('feedwordpress_diagnostics_log', $dlog);
2524 + } /* FeedWordPress::email_diagnostic_log () */
2525 +
2526 + static function allow_html_mail () {
2527 + return 'text/html';
2528 + } /* FeedWordPress::allow_html_mail () */
2529 +
2530 + static function admin_footer () {
2531 + global $feedwordpress_admin_footer;
2532 + foreach ($feedwordpress_admin_footer as $line) :
2533 + echo '<div><pre>'.$line.'</pre></div>';
2534 + endforeach;
2535 + } /* FeedWordPress::admin_footer () */
2536 +
2537 + static function log_prefix ($date = false) {
2538 + $home = get_bloginfo('url');
2539 + $prefix = '['.feedwordpress_display_url($home).'] [feedwordpress] ';
2540 + if ($date) :
2541 + $prefix = "[".date('Y-m-d H:i:s')."]".$prefix;
2542 + endif;
2543 + return $prefix;
2544 + } /* FeedWordPress::log_prefix () */
2545 +
2546 + static function menu_cap ($sub = false) {
2547 + if ($sub) :
2548 + $cap = apply_filters('feedwordpress_menu_settings_capacity', 'manage_options');
2549 + else :
2550 + $cap = apply_filters('feedwordpress_menu_main_capacity', 'manage_links');
2551 + endif;
2552 + return $cap;
2553 + } /* FeedWordPress::menu_cap () */
2554 +
2555 + static function path ($filename = '') {
2556 + global $fwp_path;
2557 +
2558 + $path = $fwp_path;
2559 + if (strlen($filename) > 0) :
2560 + $path .= '/'.$filename;
2561 + endif;
2562 + return $path;
2563 + } /* FeedWordPress::path () */
2564 +
2565 + // These are superceded by MyPHP::param/post/get/request, but kept
2566 + // here for backward compatibility.
2567 +
2568 + static function param ($key, $type = 'REQUEST', $default = NULL) {
2569 + return MyPHP::param($key, $default, $type);
2570 + } /* FeedWordPress::param () */
2571 +
2572 + static function post ($key, $default = NULL) {
2573 + return MyPHP::post($key, $default);
2574 + } /* FeedWordPress::post () */
2575 +
2576 +} /* class FeedWordPress */
2577 +
2578 +$feedwordpress_admin_footer = array();
1300 2579
1301 2580 // take your best guess at the realname and e-mail, given a string
1302 2581 define('FWP_REGEX_EMAIL_ADDY', '([^@"(<\s]+@[^"@(<\s]+\.[^"@(<\s]+)');
1303 2582 define('FWP_REGEX_EMAIL_NAME', '("([^"]*)"|([^"<(]+\S))');