CUNY Academic Commons

				$query->set('ondate',false);

			}

		}

		$query->set( 'post_type', 'event' );

		$query->set( 'event_start_before', $ondate_end );

		$query->set( 'event_end_after', $ondate_start );

	//@see https://github.com/stephenharris/Event-Organiser/issues/30

	if( $query->is_main_query() ){

		if( eo_is_event_archive( 'day' ) || eo_is_event_archive( 'month' ) || eo_is_event_archive( 'year' ) ){

		}

	$blog_now = new DateTime(null, eo_get_blog_timezone());

	//Determine whether or not to show past events and each occurrence. //If not set, use options

 */

function eventorganiser_event_fields( $select, $query ){

	global $wpdb;

	$q_fields = $query->get( 'fields' );

	if( eventorganiser_is_event_query( $query, true ) && 'ids' != $q_fields && 'id=>parent' != $q_fields ){

		$et =$wpdb->eo_events;

		$select .= ", {$et}.event_id, {$et}.event_id AS occurrence_id, {$et}.StartDate, {$et}.StartTime, {$et}.EndDate, {$et}.FinishTime, {$et}.event_occurrence ";

	if( eventorganiser_is_event_query( $query, true ) ){

		if( 'series'== $query->get('group_events_by') ) {

						AS {$wpdb->eo_events} ON $wpdb->posts.id = {$wpdb->eo_events}.post_id ";

		}else{

 * @return bool True if the query is an event query. False otherwise.

 */

function eventorganiser_is_event_query( $query, $exclusive = false ){

	$post_types = $query->get( 'post_type' );

	if( 'any' == $post_types ){

		$post_types = get_post_types( array('exclude_from_search' => false) );

	if( 'event' == $post_types || array( 'event' ) == $post_types ){

		$bool = true;

	}elseif( ( $query && $query->is_feed( 'eo-events' ) ) || is_feed( 'eo-events' ) ){

		$bool = true;

	}elseif( empty( $post_types ) && eo_is_event_taxonomy( $query ) ){

		//Querying by taxonomy - check if 'event' is the only post type

		$post_types = array();

		$taxonomies = wp_list_pluck( $query->tax_query->queries, 'taxonomy' );

		foreach ( get_post_types() as $pt ) {

			$object_taxonomies = ( $pt === 'attachment' ? get_taxonomies_for_attachments() : get_object_taxonomies( $pt ) );

			if ( array_intersect( $taxonomies, $object_taxonomies ) ) {

				$post_types[] = $pt;

			}

		}

	}elseif( $exclusive ){

		$bool = false;

	}elseif( ( is_array( $post_types ) && in_array( 'event', $post_types ) ) ){

		$bool = true;

	}else{

		$bool = false;

	}

	/**

	 * Filters whether the query is an event query.

	 * if the query is exclusively for events.

	 * @param bool     $bool      Whether the query is an event query.

	 * @param WP_Query $query     The WP_Query instance to check.

	 */

	return apply_filters( 'eventorganiser_is_event_query', $bool, $query, $exclusive );

}

			$occurrence_id =$query->query_vars['event_occurrence_id'];

			$where .= $wpdb->prepare(" AND {$wpdb->eo_events}.event_id=%d ",$occurrence_id);

		endif;

		//https://core.trac.wordpress.org/ticket/16471

		if( isset( $query->query_vars['event_occurrence__not_in'] ) ):

			$occurrence__not_in = implode(', ', array_map( 'intval', $query->query_vars['event_occurrence__not_in'] ) );

			$where .= " AND {$wpdb->eo_events}.event_id NOT IN({$occurrence__not_in}) ";

		endif;

		//https://core.trac.wordpress.org/ticket/16471

		if( isset( $query->query_vars['event_occurrence__in'] ) ):

			$occurrence__in = implode(', ', array_map( 'intval', $query->query_vars['event_occurrence__in'] ) );

			$where .= " AND {$wpdb->eo_events}.event_id IN({$occurrence__in}) ";

		endif;

		$date_queries = array(

			'event_start_after'=>array(

				'notstrict' =>" AND {$wpdb->eo_events}.StartDate >= %s ",

				$time = eo_format_date($datetime,'H:i:s');

				if( $time == '00:00:00' ){

					$sql = $_sql['notstrict'];

				}else{

					$sql = $_sql['strict'];

				}

			}

		}

function _eventorganiser_update_event_dates_cache( $events, $query ){

	// No point in doing all this work if we didn't match any posts.

	if ( ! $events ) {

		return $events;

	if ( version_compare( PHP_VERSION, '5.3.0' ) < 0 ) {

		return $events;

	}

	//TODO do we need to check if $events is an array of WP_Post objects?

	//TODO allow this to be skipped?

	}

	$tz = eo_get_blog_timezone();

	foreach ( $events as $event ) {

		$id = $event->ID;

		$cached_event = wp_cache_get( 'eventorganiser_occurrences_'.$id );

		if ( isset( $cached_event[$event->occurrence_id] ) ) {

			continue;

		}

		$cached_event[$event->occurrence_id] = 	array(

			'start' => new DateTime($event->StartDate.' '.$event->StartTime, $tz ),

			'end'   => new DateTime($event->EndDate.' '.$event->FinishTime, $tz ),

		);

		wp_cache_set( 'eventorganiser_occurrences_'.$id, $cached_event );

	}

	return $events;

}

 */

/**

* This functions updates a post of event type, with data given in the $post_data

*

* Triggers {@see `eventorganiser_save_event`} passing event (post) ID

*

*      * (string) BYMONTHDAY=XX to repeat on XXth day of month, e.g. BYMONTHDAY=01 to repeat on the first of every month.

*      * (string) BYDAY=ND. N= 1|2|3|4|-1 (first, second, third, fourth, last). D is day of week SU|MO|TU|WE|TH|FR|SA. E.g. BYDAY=2TU (repeat on second tuesday)

*   * For weekly schedules,

*      * Can be left blank to repeat weekly from the start date.

* * `frequency` => (int) positive integer, sets frequency of recurrence (every 2 days, or every 3 days etc)

* * `all_day` => 1 if its an all day event, 0 if not

* * `end` => end date (of first occurrence)  as a datetime object

* * `until` =>  **START** date of last occurrence (or upper-bound thereof) as a datetime object

* * `schedule_last` =>  Alias of until. Deprecated 2.13.0, use until.

* This is only used if `until` is not, and for daily, weekly, monthly or yearly recurring events.

* * `include` => array of datetime objects to include in the schedule

* * `exclude` => array of datetime objects to exclude in the schedule

function eo_update_event( $post_id, $event_data = array(), $post_data = array() ){

	$post_id = (int) $post_id;

	$input = array_merge( $post_data, $event_data );

	//Backwards compat:

	if( !empty( $input['venue'] ) ){

		$input['tax_input']['event-venue'] = $input['venue'];

	if( !empty( $input['category'] ) ){

		$input['tax_input']['event-category'] = $input['category'];

	}

		'all_day', 'until', 'schedule_last', 'include', 'exclude', 'occurs_by', 'number_occurrences',

	) );

	$post_keys = array_flip( array(

		'to_ping', 'pinged', 'post_password', 'guid', 'post_content_filtered', 'post_excerpt', 'import_id', 'tax_input',

		'comment_status', 'context', 'post_date', 'post_date_gmt',

	) );

	$event_data = array_intersect_key( $input, $event_keys );

	$post_data = array_intersect_key( $input, $post_keys ) + $post_data;

	if( empty( $post_id ) ){

		return new WP_Error( 'eo_error', 'Empty post ID.' );

	}

	/**

	 *@ignore

	 */

	$post_data = apply_filters( 'eventorganiser_update_event_post_data', $post_data, $post_id, $post_data, $event_data );

	if( !empty($post_data) ){

		wp_update_post( $post_data );

	}

		}

		unset( $event_data['schedule_last'] );

	}

	//Get previous data, parse with data to be updated

	$prev = eo_get_event_schedule( $post_id );

	$event_data = wp_parse_args( $event_data, $prev );

	if( ( empty($event_data['schedule']) || 'once' == $event_data['schedule'] ) && !empty($event_data['include']) ){

		$event_data['schedule'] = 'custom';

	}

	$event_data = _eventorganiser_generate_occurrences( $event_data );

	if( is_wp_error( $event_data ) ){

*      * (string) BYMONTHDAY=XX to repeat on XXth day of month, e.g. BYMONTHDAY=01 to repeat on the first of every month.

*      * (string) BYDAY=ND. N= 1|2|3|4|-1 (first, second, third, fourth, last). D is day of week SU|MO|TU|WE|TH|FR|SA. E.g. BYDAY=2TU (repeat on second tuesday)

*   * For weekly schedules,

*      * Can be left blank to repeat weekly from the start date.

* * `frequency` => (int) positive integer, sets frequency of recurrence (every 2 days, or every 3 days etc)

* * `all_day` => 1 if its an all day event, 0 if not

* * `end` => end date (of first occurrence)  as a datetime object

* * `until` =>  **START** date of last occurrence (or upper-bound thereof) as a datetime object

* * `schedule_last` =>  Alias of until. Deprecated 2.13.0, use until.

* This is only used if `until` is not, and for daily, weekly, monthly or yearly recurring events.

* * `include` => array of datetime objects to include in the schedule

* * `exclude` => array of datetime objects to exclude in the schedule

*

*    $e = eo_insert_event($post_data,$event_data);

* </code>

* ### Tutorial

* See this <a href="http://www.stephenharris.info/2012/front-end-event-posting/">tutorial</a> or <a href="https://gist.github.com/3867194">this Gist</a> on front-end event posting.

*

* @since 1.5

* @link http://www.stephenharris.info/2012/front-end-event-posting/ Tutorial on front-end event posting

*

* @param array $post_data array of data to be used by wp_insert_post.

* @param array $event_data array of event data

	global $wpdb;

	$input = array_merge( $post_data, $event_data );

	//Backwards compat:

	if( !empty( $input['venue'] ) ){

		$input['tax_input']['event-venue'] = $input['venue'];

	if( !empty( $input['category'] ) ){

		$input['tax_input']['event-category'] = $input['category'];

	}

	$event_keys = array_flip( array(

	) );

	$post_keys = array_flip( array(

		'to_ping', 'pinged', 'post_password', 'guid', 'post_content_filtered', 'post_excerpt', 'import_id', 'tax_input',

		'comment_status', 'context',  'post_date', 'post_date_gmt',

	) );

	$event_data = array_intersect_key( $input, $event_keys ) + $event_data;

	$post_data = array_intersect_key( $input, $post_keys );

	//If schedule is 'once' and dates are included - set to 'custom':

	if( ( empty($event_data['schedule']) || 'once' == $event_data['schedule'] ) && !empty($event_data['include']) ){

		$event_data['schedule'] = 'custom';

	}

	if( !empty( $event_data['schedule_last'] ) ){

		if( !isset( $event_data['until'] ) ){

			$event_data['until'] = clone $event_data['schedule_last'];

	}

	$event_data = _eventorganiser_generate_occurrences( $event_data );

	if( is_wp_error( $event_data ) ){

		return $event_data;

	}

	 *@ignore

	 */

	$event_data = apply_filters( 'eventorganiser_insert_event_event_data', $event_data, $post_data, $event_data );

	/**

	 *@ignore

	 */

	$post_data = apply_filters( 'eventorganiser_insert_event_post_data', $post_data, $post_data, $event_data );

	//Finally we create event (first create the post in WP)

	$post_id = wp_insert_post($post_input, true);

			return $post_id;

	_eventorganiser_insert_occurrences($post_id, $event_data);

	//Action used to break cache & trigger Pro actions (& by other plug-ins?)

	/**

	 * Triggered after an event has been updated.

	 */

	do_action( 'eventorganiser_save_event', $post_id );

 *

 * This function does not update any of the event schedule details.

 * **Don't call this unless you know what you're doing**.

 * @since 1.5

 * @access private

 * @param int $post_id the event's (post) ID to be deleted

 * @param int|array $occurrence_ids Occurrence ID (or array of IDs) for specificaly occurrences to delete. If empty/false, deletes all.

 */

function eo_delete_event_occurrences( $event_id, $occurrence_ids = false ){

	global $wpdb;

	//TODO use this in break/remove occurrence

	//Let's just ensure empty is cast as false

	$occurrence_ids = ( empty( $occurrence_ids ) ? false : $occurrence_ids );

	if( $occurrence_ids !== false ){

		$occurrence_ids = (array) $occurrence_ids;

		$occurrence_ids = array_map( 'absint', $occurrence_ids );

		$occurrence_ids_in = implode( ', ', $occurrence_ids );

		$raw_sql = "DELETE FROM $wpdb->eo_events WHERE post_id=%d AND event_id IN( $occurrence_ids_in )";

	}else{

		$raw_sql = "DELETE FROM $wpdb->eo_events WHERE post_id=%d";

	}

	/**

	 * @ignore

	 */

	do_action( 'eventorganiser_delete_event', $event_id, $occurrence_ids ); //Deprecated - do not use!

	/**

	 * Triggers just before the specified occurrences for the event are deleted.

	 * @param int $event_id The (post) ID of the event of which we're deleting occurrences.

	 * @param array|false $occurrence_ids An array of occurrences to be delete. If `false`, all occurrences are to be removed.

	 */

	do_action( 'eventorganiser_delete_event_occurrences', $event_id, $occurrence_ids );

	$del = $wpdb->get_results( $wpdb->prepare(  $raw_sql, $event_id ) );

}

add_action( 'delete_post', 'eo_delete_event_occurrences', 10 );

* @return int $post_id

*/

function _eventorganiser_insert_occurrences( $post_id, $event_data ){

	global $wpdb;

	extract( $event_data );

	$tz = eo_get_blog_timezone();

	//Also see https://github.com/stephenharris/Event-Organiser/issues/205

	//And https://github.com/stephenharris/Event-Organiser/issues/224

	$duration_str = eo_date_interval( $start, $end, '+%y year +%m month +%d days +%h hours +%i minutes +%s seconds' );

	$event_data['duration_str'] = $duration_str;

	$schedule_last_end = clone $schedule_last;

	//Get dates to be deleted / added

	$current_occurrences = eo_get_the_occurrences( $post_id );

	$current_occurrences = $current_occurrences ? $current_occurrences : array();

	$delete   = array_udiff( $current_occurrences, $occurrences, '_eventorganiser_compare_dates' );

	$insert   = array_udiff( $occurrences, $current_occurrences, '_eventorganiser_compare_dates' );

	$update   = array_uintersect( $occurrences, $current_occurrences, '_eventorganiser_compare_dates' );

	$update_2 = array_uintersect( $current_occurrences, $update, '_eventorganiser_compare_dates' );

	$keys     = array_keys( $update_2 );

	if( $delete ){

		$delete_occurrence_ids = array_keys( $delete );

		eo_delete_event_occurrences( $post_id, $delete_occurrence_ids );

	}

	$occurrence_cache = array();

	$occurrence_array = array();

	if( $update ){

		$update   = array_combine( $keys, $update );

		foreach( $update as $occurrence_id => $occurrence ){

			$occurrence_end = clone $occurrence;

			$occurrence_end->modify($duration_str);

			$occurrence_input = array(

				'StartDate'        => $occurrence->format('Y-m-d'),

				'StartTime'        => $occurrence->format('H:i:s'),

			);

			$wpdb->update(

				array( 'event_id' => $occurrence_id )

			);

			);

		}

	}

	if( $insert ){

		foreach( $insert as $counter => $occurrence ):

			$occurrence_end = clone $occurrence;

			);

			$wpdb->insert( $wpdb->eo_events, $occurrence_input );

			$occurrence_array[$wpdb->insert_id] = $occurrence->format('Y-m-d H:i:s');

			//Add to occurrence cache: TODO use post meta

		endforeach;

	}

	//Set occurrence cache

	wp_cache_set( 'eventorganiser_occurrences_'.$post_id, $occurrence_cache );

	wp_cache_set( 'eventorganiser_all_occurrences_'.$post_id, $occurrence_cache );

	unset( $event_data['occurrences'] );

	//$event_data['_occurrences'] = $occurrence_array;

	if( !empty($include) ){

		$event_data['include'] = array_map('eo_format_datetime', $include, array_fill(0, count($include), 'Y-m-d H:i:s') );

	}

	if( !empty($exclude) ){

		$event_data['exclude'] = array_map('eo_format_datetime', $exclude, array_fill(0, count($exclude), 'Y-m-d H:i:s') );

	}

	unset( $event_data['schedule_start'] );

	unset( $event_data['schedule_last'] );

	unset( $event_data['until'] );

	update_post_meta( $post_id, '_eventorganiser_event_schedule', $event_data );

	update_post_meta( $post_id, '_eventorganiser_schedule_start_start', $start->format('Y-m-d H:i:s') );

	update_post_meta( $post_id, '_eventorganiser_schedule_start_finish', $end->format('Y-m-d H:i:s') );

	update_post_meta( $post_id, '_eventorganiser_schedule_until', $until->format('Y-m-d H:i:s') );

	update_post_meta( $post_id, '_eventorganiser_schedule_last_start', $schedule_last->format('Y-m-d H:i:s') );

	update_post_meta( $post_id, '_eventorganiser_schedule_last_finish', $schedule_last_end->format('Y-m-d H:i:s') );

	return $post_id;

}

*      * (string) BYMONTHDAY=XX to repeat on XXth day of month, e.g. BYMONTHDAY=01 to repeat on the first of every month.

*      * (string) BYDAY=ND. N= 1|2|3|4|-1 (first, second, third, fourth, last). D is day of week SU|MO|TU|WE|TH|FR|SA. E.g. BYDAY=2TU (repeat on second tuesday)

*   * For weekly schedules,

* * `occurs_by` - For use with monthly schedules: how the event recurs: BYDAY or BYMONTHDAY

* * `frequency` => (int) positive integer, sets frequency of recurrence (every 2 days, or every 3 days etc)

* * `all_day` => 1 if its an all day event, 0 if not

* * `start` =>  start date (of first occurrence)  as a datetime object

* * `end` => end date (of first occurrence)  as a datetime object

* * `until` => For recurring events, the date they repeat until. Note that this may not be equal to `schedule_last` if

* * `schedule_last` =>  **START** date of last occurrence as a datetime object

* * `include` => array of datetime objects to include in the schedule

* * `exclude` => array of datetime objects to exclude in the schedule

	$post_id = (int) ( empty($post_id) ? get_the_ID() : $post_id);

		return false;

	}

	} else {

		// No start time, so set a default start time to next half-hour

		$now = new DateTime( 'now', $tz );

		$minute = $now->format( 'i' ) > 30 ? 0 : 30;

		$now->setTime( $now->format( 'G' ), $minute );

		if( 0 === $minute ){

			$now->modify( '+1 hour' );

		}

	}

	// Get end time

		$event_details['until'] = clone $event_details['schedule_last'];

		update_post_meta( $post_id, '_eventorganiser_schedule_until', $event_details['until']->format( 'Y-m-d H:i:s' ) );

	}

	if ( ! empty( $event_details['include'] ) ) {

		$event_details['include'] = array_map( 'eventorganiser_date_create', $event_details['include'] );

	}

	/**

	 * Filters the schedule metadata for an event (as returned by `eo_get_event_schedule()`.

	 * See documentation on `eo_get_event_schedule()` for more details.

	 *

	 * @param array $event_details Details of the event's dates and recurrence pattern

	$event_defaults = array(

		'start' => '', 'end' => '', 'all_day' => 0,

		'until' => '', 'number_occurrences' => 0, 'exclude' => array(), 'include' => array(),

	);

	extract( wp_parse_args( $event_data, $event_defaults ) );

		$exclude = array_filter( (array) $exclude );

		$include = array_filter( (array) $include );

		$exclude = array_udiff($exclude, $include, '_eventorganiser_compare_datetime');

		$include = array_udiff($include, $exclude, '_eventorganiser_compare_datetime');

		//White list schedule

		if( !in_array($schedule, array('once','daily','weekly','monthly','yearly','custom')) )

			return new WP_Error('eo_error',__('Schedule not recognised.','eventorganiser'));

		//Ensure event frequency is a positive integer. Else set to 1.

		$frequency = max(absint($frequency),1);

		$all_day = (int) $all_day;

		$number_occurrences = absint( $number_occurrences );

		//Check dates are supplied and are valid

		if( !($start instanceof DateTime) )

			return new WP_Error('eo_error',__('Start date not provided.','eventorganiser'));

		if( !($end instanceof DateTime) )

			$end = clone $start;

		//If use 'number_occurrences' to limit recurring event, set dummy 'schedule_last' date.

		if( !($until instanceof DateTime) && $number_occurrences && in_array( $schedule, array( 'daily','weekly','monthly','yearly' ) ) ){

			//Set dummy "last occurrance" date.

		//Check dates are in chronological order

		if($end < $start)

			return new WP_Error('eo_error',__('Start date occurs after end date.','eventorganiser'));

		if($until < $start)

			return new WP_Error('eo_error',__('Schedule end date is before is before the start date.','eventorganiser'));

		$start_days =array();

		$workaround='';

		$icaldays = array('SU','MO','TU','WE','TH','FR','SA');

		$ical2day = array('SU'=>'Sunday','MO'=>'Monday','TU'=>'Tuesday','WE'=>'Wednesday','TH'=>'Thursday','FR'=>'Friday','SA'=>'Saturday');

		//Set up schedule

			case 'daily':

				$interval = "+".$frequency."day";

				$start_days[] = clone $start;

			case 'weekly':

				$schedule_meta = ( $schedule_meta ? array_filter($schedule_meta) : array() );

				$rule =$rule_value[0];

				$values = !empty( $rule_value[1] ) ? explode(',',$rule_value[1]) : array();//Should only be one value, but may support more in future

				$values =  array_filter( $values );

				if( $rule=='BYMONTHDAY' ):

					$date = (int) $start_days[0]->format('d');

					$interval = "+".$frequency."month";

					if($date >= 29)

						$workaround = 'short months';	//This case deals with 29/30/31 of month

					$day = $weekdays[$day_num];//Full day name from day_num (Sunday -Monday)

					$schedule_meta = 'BYDAY='.$n.$ical_day; //E.g. BYDAY=2MO

					$interval = $ordinal[$n].' '.$day.' of +'.$frequency.' month'; //E.g. second monday of +1 month

					//Work around for PHP <5.3

					if(!function_exists('date_diff')){

						$workaround = 'php5.2';

					}

				endif;

				break;

			case 'yearly':

				$start_days[] = clone $start;

				if( '29-02' == $start_days[0]->format('d-m') )

					$workaround = 'leap year';

				$interval = "+".$frequency."year";

				break;

		endswitch; //End $schedule switch

		foreach($start_days as $index => $start_day):

			$current = clone $start_day;

			$occurrence_n = 0;

			switch($workaround):

				//Not really a workaround. Just add the occurrence and finish.

				case 'once':

					$current->setTime($H,$i );

					$occurrences[] = clone $current;

					break;

				//Loops for monthly events that require php5.3 functionality

				case 'php5.2':

					while( $current <= $until || $occurrence_n < $number_occurrences ):

						$current->setTime($H,$i );

						$current = _eventorganiser_php52_modify($current,$interval);

						$occurrence_n++;

					break;

				//Loops for monthly events on the 29th/30th/31st

				case 'short months':

					 $day_int =intval($start_day->format('d'));

					//Set the first month

					$current_month= clone $start_day;

					$current_month = date_create($current_month->format('Y-m-1'));

					while( $current_month <= $until || $occurrence_n < $number_occurrences ):

						if( checkdate($month_int , $day_int , $year_int) ){

							$current = new DateTime($day_int.'-'.$month_int.'-'.$year_int, $timezone);

							$occurrence_n++;

						}

						$current_month->modify($interval);

					break;

				//To be used for yearly events occuring on Feb 29

					$current_year = clone $current;

					$current_year->modify('-1 day');

						$is_leap_year = (int) $current_year->format('L');

						if( $is_leap_year ){

						$current_year->modify( $interval );

					endwhile;

					break;

				default:

					while( $current <= $until || $occurrence_n < $number_occurrences  ):

						$current->setTime($H,$i );

						$current->modify( $interval );

						$occurrence_n++;

					endwhile;

			$occurrences =  array_slice( $occurrences, 0, $number_occurrences );

			$until = end( $occurrences );

		}

		//Cast includes/exclude to timezone

		$tz = eo_get_blog_timezone();

		if( $include ){

				$excluded_date->setTimezone( $tz );

			}

		}

		//Add inclusions, removes exceptions and duplicates

		if( defined( 'WP_DEBUG' ) && WP_DEBUG ){

			//Make sure 'included' dates doesn't appear in generate date

			$include = array_udiff( $include, $occurrences, '_eventorganiser_compare_datetime' );

		}

		$occurrences = array_udiff( $occurrences, $exclude, '_eventorganiser_compare_datetime') ;

		$occurrences = _eventorganiser_remove_duplicates($occurrences);

		//Sort occurrences

		sort($occurrences);

		if( empty( $occurrences ) || !$occurrences[0] || !( $occurrences[0] instanceof DateTime ) ){

			return new WP_Error('eo_error',__('Event does not contain any dates.','eventorganiser'));

		}

			'include'        => $include,

			'occurrences'    => $occurrences,

		);

		/**

		 * Filters the event schedule after its dates has been generated by a given schedule.

		 * schedule which may include:

		 * * **start** (DateTime) -  when the event starts

		 * * **end** (DateTime) - when the event ends

		 * * **all_day** (Bool) - If the event is all day or no

		 * * **exclude** (array) - Array of DateTime objects  to exclude from the schedule

		 * * **include** (array) - Array of DateTime objects to include in the schedule

		 * * **occurrences** (array) - Array of DateTime objects generated from the above schedule.

		 * @param array $_event_data The event schedule with generated occurrences.

		 */

		$_event_data = apply_filters( 'eventorganiser_generate_occurrences', $_event_data, $event_data );

		return $_event_data;

	}

/**

 * @access private

 * @ignore

 * @since 1.0.0

			return false;

		extract($rrule);

		$schedule_last->setTimezone( new DateTimeZone('UTC') );

		$schedule_last = $schedule_last->format( 'Ymd\THis\Z' );

				$recurrence_rule .=$schedule_meta.";";

				$recurrence_rule .= "UNTIL=".$schedule_last;

				return $recurrence_rule;

			case 'weekly':

				if( !eo_is_all_day( $post_id ) ){

					//None all day event, setting event timezone to UTC may cause it to shift days.

					//E.g. a 9pm Monday event in New York will a Tuesday event in UTC.

					//We may need to correct the BYDAY attribute to be valid for UTC.

					$days_of_week = array( 'SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA' );

					$UTC = new DateTimeZone('UTC');

					//Get day shift upon timezone set to UTC

					$start = eo_get_schedule_start( DATETIMEOBJ, $post_id );

					$local_day = (int) $start->format( 'w' );

					$start->setTimezone( $UTC );

					$utc_day = (int) $start->format( 'w' );

					$diff = $utc_day - $local_day + 7; //ensure difference is positive (should be 0, +1 or +6).

					//If there is a shift correct BYDAY

					if( $diff ){

						$utc_days = array();

						foreach( $schedule_meta as $day ){

							$utc_day_index = ( array_search( $day, $days_of_week ) + $diff ) %7;

							$utc_days[] = $days_of_week[$utc_day_index];

						}

						$schedule_meta = $utc_days;

					}

				}

				return "FREQ=WEEKLY;INTERVAL=".$frequency.";BYDAY=".implode(',',$schedule_meta).";UNTIL=".$schedule_last;

			case 'daily':

}

function eventorganiser_ical_vtimezone( $timezone, $from, $to ) {

	$vtimezone = "BEGIN:VTIMEZONE\r\n";

	$vtimezone .= sprintf( "TZID:%s\r\n", $timezone->getName() );

	//$timezone->getTransitions() doesn't accept any arguments in php 5.2, and would be ineffecient

	if ( version_compare( PHP_VERSION, '5.3.0' ) < 0 ) {

		return '';

	}

	// get all transitions, and (as an estimate) an early one which we skip

	$transitions = $timezone->getTransitions( $from - YEAR_IN_SECONDS / 2, $to );

	if ( ! $transitions ) {

		return '';

	}

	foreach ( $transitions as $i => $trans ) {

		$pm      = $trans['offset'] >= 0 ? '+' : '-';

 		$hours   = floor( absint( $trans['offset'] ) / HOUR_IN_SECONDS ) % 24;

		$minutes = ( absint( $trans['offset'] ) - $hours * HOUR_IN_SECONDS ) / MINUTE_IN_SECONDS;

		$tzto = $pm . str_pad( $hours, 2, '0', STR_PAD_LEFT ) . str_pad( $minutes, 2, '0', STR_PAD_LEFT );

		// skip the first entry, we just want it for the TZOFFSETFROM value of the next one

		if ( $i == 0 ) {

			$tzfrom = $tzto;

				continue;

			}

		}

		$dt   = new DateTime( $trans['time'], $timezone );

		$vtimezone .= sprintf( "BEGIN:%s\r\n", $type );

		$vtimezone .= sprintf( "TZOFFSETFROM:%s\r\n", $tzfrom ); //needs formatting

		$vtimezone .= sprintf( "TZOFFSETTO:%s\r\n", $tzto ); //needs formatting

		$vtimezone .= sprintf( "DTSTART:%s\r\n",  $dt->format('Ymd\THis') );

		$vtimezone .= sprintf( "END:%s\r\n", $type );

	}

	$vtimezone .= 'END:VTIMEZONE';

	return $vtimezone;

}

		global $wpdb;

		$remove = $wpdb->get_row($wpdb->prepare(

			WHERE post_id=%d AND event_id=%d",$post_id,$event_id));

		if( !$remove )

		}

		//Update post meta and delete date from events table

		eo_delete_event_occurrences( $post_id, $event_id );

		//Clear cache

		return true;

	}

/**

 * Currently two occurrences cannot occupy the same date.

 * @ignore

 * @access private

 * @since 2.12.0

 * @param int $event_id      ID of the event whose occurrence we're moving

 * @param int $occurrence_id ID of the occurrence we're moving

 * @param DateTime $start    New start DateTime of the occurrence

function eventorganiser_move_occurrence( $event_id, $occurrence_id, $start, $end ){

	global $wpdb;

	$old_start = eo_get_the_start( DATETIMEOBJ, $event_id, null, $occurrence_id );

	$schedule  = eo_get_event_schedule( $event_id );

	if( $start == $old_start ){

		return true;

	}

	$current_occurrences = eo_get_the_occurrences( $event_id );

	unset( $current_occurrences[$occurrence_id] );

	$current_occurrences = array_map( 'eo_format_datetime', $current_occurrences );

	if( in_array( $start->format( 'd-m-Y' ), $current_occurrences ) ){

	}

	//We update the date directly in the DB first so the occurrence is not deleted and recreated,

	$wpdb->update(

		array(

			'StartDate'  => $start->format( 'Y-m-d' ),

			'StartTime'  => $start->format( 'H:i:s' ),

			'EndDate'    => $end->format( 'Y-m-d' ),

			'FinishTime' => $end->format( 'H:i:s' ),

		array( 'event_id' => $occurrence_id )

	);

	wp_cache_delete( 'eventorganiser_occurrences_'.$event_id );//Important: update DB clear cache

	wp_cache_delete( 'eventorganiser_all_occurrences_'.$event_id );//Important: update DB clear cache

	//Now update event schedule...

	//otherwise add it to exclude. Then add new date as include.

	if( false === ( $index = array_search( $old_start, $schedule['include'] ) ) ){

		$schedule['exclude'][] = $old_start;

	$schedule['include'][] = $start;

	$re = eo_update_event( $event_id, $schedule );

	if( $re && !is_wp_error( $re ) ){

		return true;

	}

	return $re;

}

?>

class recurrenceTest extends EO_UnitTestCase

{

    public function testOneOff()

    {

    	$_event_data = array(

    	$expected = array(

    			new DateTime( '2013-10-22 19:19:00', eo_get_blog_timezone() ),

    	);

    	$this->assertEquals( $expected, $event_data['occurrences'] );

    }

    public function testDaily()

    {

    	$_event_data = array(

    			'schedule' => 'daily',

    			'frequency' => 2,

    			'until' => new DateTime( '2013-11-02 20:19:00', eo_get_blog_timezone() ),

    	);

    	$event_data = _eventorganiser_generate_occurrences( $_event_data );

    	$expected = array(

    			new DateTime( '2013-10-22 19:19:00', eo_get_blog_timezone() ),

    			new DateTime( '2013-10-30 19:19:00', eo_get_blog_timezone() ),

    			new DateTime( '2013-11-01 19:19:00', eo_get_blog_timezone() )

    	);

    	$this->assertEquals( $expected, $event_data['occurrences'] );

    }

    public function testWeekly()

    {

    	$_event_data = array(

    			'schedule' => 'weekly',

    			'schedule_meta' => array( 'WE', 'FR' ),

    			'until' => new DateTime( '2013-11-02 20:19:00', eo_get_blog_timezone() ),

    	);

    	$event_data = _eventorganiser_generate_occurrences( $_event_data );

    	$expected = array(

    			new DateTime( '2013-10-23 19:19:00', eo_get_blog_timezone() ),

    			new DateTime( '2013-10-30 19:19:00', eo_get_blog_timezone() ),

    			new DateTime( '2013-11-01 19:19:00', eo_get_blog_timezone() )

    	);

    	$this->assertEquals( $expected, $event_data['occurrences'] );

    }

    public function testWeeklyWithoutMeta()

    {

    	$_event_data = array(

    			'end' => new DateTime( '2013-10-22 20:19:00', eo_get_blog_timezone() ),

    			'schedule' => 'weekly',

    			'until' => new DateTime( '2013-11-02 20:19:00', eo_get_blog_timezone() ),

    	);

    	$event_data = _eventorganiser_generate_occurrences( $_event_data );

    	$expected = array(

    			new DateTime( '2013-10-22 19:19:00', eo_get_blog_timezone() ),

    			new DateTime( '2013-10-29 19:19:00', eo_get_blog_timezone() )

    	);

    	$this->assertEquals( $expected, $event_data['occurrences'] );

    	$this->assertEquals( array( 'TU' ), $event_data['schedule_meta'] );

    }

    public function testWeeklyLimitedData()

    {

    	$_event_data = array(

    			'end' => new DateTime( '2013-10-22 20:19:00', eo_get_blog_timezone() ),

    			'schedule' => 'weekly',

    			'until' => new DateTime( '2013-11-02 20:19:00', eo_get_blog_timezone() ),

    	);

    	$event_data = _eventorganiser_generate_occurrences( $_event_data );

    	$expected = array(

    			new DateTime( '2013-10-22 19:19:00', eo_get_blog_timezone() ),

    			new DateTime( '2013-10-29 19:19:00', eo_get_blog_timezone() )

    	);

    	$this->assertEquals( $expected, $event_data['occurrences'] );

    }

    public function testMonthlyByMonthDay()

    {

    	$_event_data = array(

    			'schedule' => 'monthly',

    			'schedule_meta' => 'BYMONTHDAY',

    			'until' => new DateTime( '2014-01-22 19:19:00', eo_get_blog_timezone() ),

    	);

    	$event_data = _eventorganiser_generate_occurrences( $_event_data );

    	$expected = array(

    			new DateTime( '2013-10-22 19:19:00', eo_get_blog_timezone() ),

    			new DateTime( '2013-12-22 19:19:00', eo_get_blog_timezone() ),

    			new DateTime( '2014-01-22 19:19:00', eo_get_blog_timezone() ),

    	);

    	$this->assertEquals( $expected, $event_data['occurrences'] );

    }

    public function testMonthlyByDay()

    {

    	$_event_data = array(

    			'schedule' => 'monthly',

    			'schedule_meta' => 'BYDAY=4WE',

    			'until' => new DateTime( '2014-01-22 19:19:00', eo_get_blog_timezone() ),

    	);

    	$event_data = _eventorganiser_generate_occurrences( $_event_data );

    	$expected = array(

    			new DateTime( '2013-10-22 19:19:00', eo_get_blog_timezone() ), //Tuesday

    			new DateTime( '2013-12-25 19:19:00', eo_get_blog_timezone() ), //4th Wednesday

    			new DateTime( '2014-01-22 19:19:00', eo_get_blog_timezone() ), //4th Wednesday

    	);

    	$this->assertEquals( $expected, $event_data['occurrences'] );

    }

    public function testYearly()

    {

    	$_event_data = array(

    			'schedule' => 'yearly',

    			'frequency' => 2,

    			'until' => new DateTime( '2017-10-22 19:19:00', eo_get_blog_timezone() ),

    	);

    	$event_data = _eventorganiser_generate_occurrences( $_event_data );

    	$expected = array(

    			new DateTime( '2013-10-22 19:19:00', eo_get_blog_timezone() ),

    			new DateTime( '2015-10-22 19:19:00', eo_get_blog_timezone() ),

    			new DateTime( '2017-10-22 19:19:00', eo_get_blog_timezone() )

    	);

    	$this->assertEquals( $expected, $event_data['occurrences'] );

    }

    public function testCustom()

    {

    	$_event_data = array(

    				new DateTime( '2013-11-17 19:19:00', eo_get_blog_timezone() ),

    				new DateTime( '2013-12-06 19:19:00', eo_get_blog_timezone() ),

    			)

    	);

    	$event_data = _eventorganiser_generate_occurrences( $_event_data );

    	$expected = array(

    		new DateTime( '2013-10-22 19:19:00', eo_get_blog_timezone() ),

    		new DateTime( '2013-11-17 19:19:00', eo_get_blog_timezone() ),

    		new DateTime( '2013-12-06 19:19:00', eo_get_blog_timezone() ),

    	);

    	$this->assertEquals( $expected, $event_data['occurrences'] );

    }

    public function testLeapYear()

    {

    	$_event_data = array(

    			'schedule' => 'yearly',

    			'frequency' => 1,

    			'until' => new DateTime( '2020-02-29 00:00:00', eo_get_blog_timezone() ),

    	);

    	$event_data = _eventorganiser_generate_occurrences( $_event_data );

    	$expected = array(

    			new DateTime( '2012-02-29 00:00:00', eo_get_blog_timezone() ),

    			new DateTime( '2016-02-29 00:00:00', eo_get_blog_timezone() ),

    			new DateTime( '2020-02-29 00:00:00', eo_get_blog_timezone() )

    	);

    	$this->assertEquals( $expected, $event_data['occurrences'] );

    }

    public function testShortMonth()

    {

    	$_event_data = array(

    			'frequency' => 1,

    			'until' => new DateTime( '2013-03-31 00:00:00', eo_get_blog_timezone() ),

    			'schedule_meta' => 'BYMONTHDAY',

    	);

    	$event_data = _eventorganiser_generate_occurrences( $_event_data );

    	$expected = array(

    			new DateTime( '2012-10-31 00:00:00', eo_get_blog_timezone() ),

    			new DateTime( '2013-01-31 00:00:00', eo_get_blog_timezone() ),

    			new DateTime( '2013-03-31 00:00:00', eo_get_blog_timezone() ),

    	);

    	$this->assertEquals( $expected, $event_data['occurrences'] );

    }

    public function testNoOccurrences()

    {

    	$_event_data = array(

    			)

    	);

    	$event_data = _eventorganiser_generate_occurrences( $_event_data );

    	$this->assertInstanceOf( 'WP_Error', $event_data );

    }

    public function testNumberOccurrences()

    {

    	$_event_data = array(

    			'frequency' => 3,

    			'number_occurrences' => 3,

    	);

    	$event_data = _eventorganiser_generate_occurrences( $_event_data );

    	$expected = array(

    			new DateTime( '2013-11-01 00:00:00', eo_get_blog_timezone() ),

    			new DateTime( '2013-11-04 00:00:00', eo_get_blog_timezone() ),

    			new DateTime( '2013-11-07 00:00:00', eo_get_blog_timezone() )

    	);

    	$this->assertEquals( $expected, $event_data['occurrences'] );

    }

    public function testNumberOccurrencesWeekly(){

    	$_event_data = array(