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