HAlowins

/** MAKE SIMULTANEOUS EVENTS UNAVAILABLE IF ONE OF THEM IS BOOKED **/

/**
 * Book all events occurring simultaneously as a booking
 * @param object $booking
 * @return array
 */
function bookacti_book_all_simultaneous_events_of_booking( $booking ) {
	if( ! $booking ) { return array(); }
	
	// SET YOUR LONGEST EVENT DURATION HERE (IN DAYS)
	$max_duration = 1;
	
	$max_duration = max( 1, $max_duration );
	$booking_start_dt = new DateTime( $booking->event_start );
	$booking_end_dt = new DateTime( $booking->event_end );
	
	// Find the potentially simultaneous events
	$interval_start_dt = clone $booking_start_dt;
	if( $max_duration ) { $interval_start_dt->sub( new DateInterval( 'P' . $max_duration . 'D' ) ); }
	$interval = bookacti_sanitize_events_interval( array( 'start' => $interval_start_dt->format( 'Y-m-d h:i:s' ), 'end' => $booking->event_end ) );
	$template_ids = ! empty( $booking->template_id ) ? array( $booking->template_id ) : array();
	$events = bookacti_fetch_events( array( 'templates' => $template_ids, 'interval' => $interval, 'past_events' => 1 ) );
	
	// Check if the booked event has a simultaneous event
	$simultaneous_events = array();
	foreach( $events[ 'events' ] as $event ) {
		// Exclude the event that the customer has booked
		if( intval( $event[ 'id' ] ) === intval( $booking->event_id ) && $event[ 'start' ] === $booking->event_start && $event[ 'end' ] === $booking->event_end ) { continue; }
		
		$event_start_dt = new DateTime( $event[ 'start' ] );
		$event_end_dt = new DateTime( $event[ 'end' ] );
		
		$is_simultaneous = ( $event_start_dt <= $booking_start_dt && $event_end_dt > $booking_start_dt ) 
						|| ( $event_start_dt >= $booking_start_dt && $event_start_dt < $booking_end_dt );
		
		if( $is_simultaneous ) { $simultaneous_events[] = $event; }
	}
	
	if( ! $simultaneous_events ) { 
		bookacti_delete_metadata( 'booking', $booking->id, array( 'simultaneous_booking_group_ids' ) );
		return array();
	}
	
	// Book all the simultaneous events to their maximum quantity (to make them unavailable)
	$booking_group_ids = array();
	
	// Create the booking group
	$booking_group_data = bookacti_sanitize_booking_group_data( array( 'user_id' => 'system', 'event_group_id' => 0, 'status' => $booking->state, 'active' => 'auto' ) );
	$booking_group_id = bookacti_insert_booking_group( $booking_group_data );
	$booking_group_ids[] = $booking_group_id;

	// Create the bookings of the group
	foreach( $simultaneous_events as $event ) {
		$availability = ! empty( $events[ 'data' ][ $event[ 'id' ] ][ 'availability' ] ) ? $events[ 'data' ][ $event[ 'id' ] ][ 'availability' ] : 999;
		$booking_data = bookacti_sanitize_booking_data( array( 'group_id' => $booking_group_id, 'user_id' => 'system', 'event_id' => $event[ 'id' ], 'event_start' => $event[ 'start' ], 'event_end' => $event[ 'end' ], 'quantity' => $availability, 'status' => $booking->state, 'expiration_date' => $booking->expiration_date, 'active' => 'auto' ) );
		bookacti_insert_booking( $booking_data );
	}
	
	// Add a booking meta to identify its related booking groups
	bookacti_update_metadata( 'booking', $booking->id, array( 'simultaneous_booking_group_ids' => $booking_group_ids ) );
	
	return $booking_group_ids;
}


/**
 * Do not allow to book multiple events if some of them are simultaneous
 * @param array $validated
 * @param array $picked_events
 * @param int $quantity
 * @param int $form_id
 * @return array
 */
function bookacti_do_not_allow_to_book_simultaneous_events( $validated, $picked_events, $quantity, $form_id ) {
	// Keep one entry per event, not per group
	$single_picked_events = bookacti_reconstruct_picked_events_array( $picked_events );
	
	foreach( $single_picked_events as $picked_event1 ) {
		$picked_event1_start_dt = new DateTime( $picked_event1[ 'start' ] );
		$picked_event1_end_dt = new DateTime( $picked_event1[ 'end' ] );
		$is_simultaneous = false;
		foreach( $single_picked_events as $picked_event2 ) {
			if( $picked_event1[ 'id' ] === $picked_event2[ 'id' ] && $picked_event1[ 'start' ] === $picked_event2[ 'start' ] && $picked_event1[ 'end' ] === $picked_event2[ 'end' ] ) { continue; }
			
			$picked_event2_start_dt = new DateTime( $picked_event2[ 'start' ] );
			$picked_event2_end_dt = new DateTime( $picked_event2[ 'end' ] );
			
			$is_simultaneous = ( $picked_event2_start_dt <= $picked_event1_start_dt && $picked_event2_end_dt > $picked_event1_start_dt ) 
							|| ( $picked_event2_start_dt >= $picked_event1_start_dt && $picked_event2_start_dt < $picked_event1_end_dt );
			
			if( $is_simultaneous ) {
				$validated[ 'status' ] = 'failed';
				$validated[ 'error' ] = 'simultaneous_events';
				$validated[ 'messages' ][ 'simultaneous_events' ] = array( 'You cannot book events that are taking place at the same time.' );
				break;
			}
		}
		if( $is_simultaneous ) { break; }
	}
	
	return $validated;
}
add_filter( 'bookacti_validate_booking_form', 'bookacti_do_not_allow_to_book_simultaneous_events', 10, 4 );


/**
 * When a customer book an event, also book the other simultaneous events
 * @global boolean $bookacti_book_all_simultaneous_events_processing
 * @param array $booking_data
 */
function bookacti_book_all_simultaneous_events_of_new_booking( $booking_data ) {
	global $bookacti_book_all_simultaneous_events_processing;
	if( $bookacti_book_all_simultaneous_events_processing ) { return; }
	$bookacti_book_all_simultaneous_events_processing = true;
	
	$booking = bookacti_get_booking_by_id( $booking_data[ 'id' ] );
	bookacti_book_all_simultaneous_events_of_booking( $booking );
	
	$bookacti_book_all_simultaneous_events_processing = false;
}
add_action( 'bookacti_booking_inserted', 'bookacti_book_all_simultaneous_events_of_new_booking', 10, 1 );


/**
 * Book all simultaneous events when a booking is rescheduled, and remove the bookings for the simultaneous events of the old booking
 * @global boolean $bookacti_book_all_simultaneous_events_processing
 * @param object $new_booking
 * @param object $old_booking
 * @param array $args
 */
function bookacti_book_all_simultaneous_events_of_rescheduled_booking( $new_booking, $old_booking, $args ) {
	global $bookacti_book_all_simultaneous_events_processing;
	if( $bookacti_book_all_simultaneous_events_processing ) { return; }
	$bookacti_book_all_simultaneous_events_processing = true;
	
	// Remove the booked simultaneous events of the old booking
	if( ! empty( $old_booking->simultaneous_booking_group_ids ) ) {
		$booking_group_ids = maybe_unserialize( $old_booking->simultaneous_booking_group_ids );
		foreach( $booking_group_ids as $booking_group_id ) {
			bookacti_delete_booking_group_bookings( $booking_group_id );
			bookacti_delete_booking_group( $booking_group_id );
		}
	}
	
	// Book the simultaneous events of the new booking
	bookacti_book_all_simultaneous_events_of_booking( $new_booking );
	
	$bookacti_book_all_simultaneous_events_processing = false;
}
add_action( 'bookacti_booking_rescheduled', 'bookacti_book_all_simultaneous_events_of_rescheduled_booking', 10, 3 );


/**
 * Change the simultaneous events state according to the booking state
 * @global boolean $bookacti_change_simultaneous_events_state_processing
 * @param object|int $booking
 * @param string $new_status
 */
function bookacti_change_simultaneous_events_state_according_to_booking( $booking, $new_status = '' ) {
	global $bookacti_change_simultaneous_events_state_processing;
	if( $bookacti_change_simultaneous_events_state_processing ) { return; }
	$bookacti_change_simultaneous_events_state_processing = true;
	
	// Get simultaneous_booking_group_ids
	$booking_id = is_numeric( $booking ) ? $booking : $booking->id;
	$booking_group_ids = is_object( $booking ) && isset( $booking->simultaneous_booking_group_ids ) ? maybe_unserialize( $booking->simultaneous_booking_group_ids ) : bookacti_get_metadata( 'booking', $booking_id, 'simultaneous_booking_group_ids', true );
	
	// Get up to date booking
	if( ! is_object( $booking ) ) { $booking = bookacti_get_booking_by_id( $booking_id ); }
	if( $new_status ) { 
		$booking->state = $new_status;
		$booking->active = in_array( $new_status, bookacti_get_active_booking_states(), true ) ? 1 : 0;
	}
	
	if( ! $booking_group_ids ) { $booking_group_ids = bookacti_book_all_simultaneous_events_of_booking( $booking ); }
	
	if( $booking_group_ids ) {
		foreach( $booking_group_ids as $booking_group_id ) {
			bookacti_update_booking_group_state( $booking_group_id, $booking->state, $booking->active, true );
		}
	}
	
	$bookacti_change_simultaneous_events_state_processing = false;
}
add_action( 'bookacti_booking_state_changed', 'bookacti_change_simultaneous_events_state_according_to_booking', 10, 2 );
add_action( 'bookacti_booking_expired', 'bookacti_change_simultaneous_events_state_according_to_booking', 10, 1 );


/**
 * Change the simultaneous events state according to the order bookings state
 * @param array $cart_item_booking
 * @param array $sanitized_data
 * @param array $item
 * @param array $new_data
 */
function bookacti_change_simultaneous_events_state_according_to_cart_item_bookings( $cart_item_booking, $sanitized_data, $item, $new_data ) {
	if( empty( $new_data[ 'status' ] ) ) { return; }
	
	$cart_items_bookings = bookacti_wc_get_cart_items_bookings( array( $item[ 'key' ] => $item ), array( 'fetch_meta' => true ) );
	if( empty( $cart_items_bookings[ $item[ 'key' ] ] ) ) { return; }
	$cart_item_bookings = $cart_items_bookings[ $item[ 'key' ] ];
	
	foreach( $cart_item_bookings as $cart_item_booking ) {
		foreach( $cart_item_booking[ 'bookings' ] as $booking ) {
			bookacti_change_simultaneous_events_state_according_to_booking( $booking );
		}
	}
}
add_action( 'bookacti_wc_cart_item_booking_updated', 'bookacti_change_simultaneous_events_state_according_to_cart_item_bookings', 100, 4 );


/**
 * Change the simultaneous events state according to the order bookings state
 * @param array $order_item_booking
 * @param array $sanitized_data
 * @param WC_Order $order
 * @param array $new_data
 * @param array $where
 */
function bookacti_change_simultaneous_events_state_according_to_order_item_bookings( $order_item_booking, $sanitized_data, $order, $new_data, $where ) {
	if( empty( $new_data[ 'status' ] ) ) { return; }
	
	foreach( $order_item_booking[ 'bookings' ] as $booking ) {
		bookacti_change_simultaneous_events_state_according_to_booking( $booking, $new_data[ 'status' ] );
	}
}
add_action( 'bookacti_wc_order_item_booking_updated', 'bookacti_change_simultaneous_events_state_according_to_order_item_bookings', 100, 5 );


/**
 * Change the simultaneous events state according to the merged booking state
 * @param array $cart_item_data
 * @param array $old_cart_item
 */
function bookacti_change_simultaneous_events_state_according_to_merged_booking( $cart_item_data, $old_cart_item ) {
	$cart_items_bookings = bookacti_wc_get_cart_items_bookings( array( 'temp_key' => $cart_item_data ), array( 'fetch_meta' => true ) );
	if( empty( $cart_items_bookings[ 'temp_key' ] ) ) { return $cart_item_data; }
	$cart_item_bookings = $cart_items_bookings[ 'temp_key' ];
	
	foreach( $cart_item_bookings as $cart_item_booking ) {
		foreach( $cart_item_booking[ 'bookings' ] as $booking ) {
			bookacti_change_simultaneous_events_state_according_to_booking( $booking );
		}
	}
}
add_action( 'bookacti_cart_item_merged', 'bookacti_change_simultaneous_events_state_according_to_merged_booking', 100, 2 );


/**
 * Delete the simultaneous events bookings when the booking is deleted
 * @global boolean $bookacti_change_simultaneous_events_state_processing
 * @param int $booking_id
 */
function bookacti_delete_simultaneous_events_bookings( $booking_id ) {
	global $bookacti_change_simultaneous_events_state_processing;
	if( $bookacti_change_simultaneous_events_state_processing ) { return; }
	$bookacti_change_simultaneous_events_state_processing = true;
	
	$booking_group_ids = bookacti_get_metadata( 'booking', $booking_id, 'simultaneous_booking_group_ids', true );
	$booking = bookacti_get_booking_by_id( $booking_id );
	
	if( $booking_group_ids ) {
		foreach( $booking_group_ids as $booking_group_id ) {
			bookacti_delete_booking_group_bookings( $booking_group_id );
			bookacti_delete_booking_group( $booking_group_id );
		}
	}
	
	$bookacti_change_simultaneous_events_state_processing = false;
}
add_action( 'bookacti_before_delete_booking', 'bookacti_delete_simultaneous_events_bookings', 10, 1 );


/**
 * Hide bookings made by "system" in backend bookings list
 */
function bookacti_hide_system_bookings() {
	if( empty( $_REQUEST[ 'not_in__user_id' ] ) )		{ $_REQUEST[ 'not_in__user_id' ] = array(); }
	if( is_numeric( $_REQUEST[ 'not_in__user_id' ] ) 
	||  is_string( $_REQUEST[ 'not_in__user_id' ] ) )	{ $_REQUEST[ 'not_in__user_id' ] = array( $_REQUEST[ 'not_in__user_id' ] ); }
	if( ! is_array( $_REQUEST[ 'not_in__user_id' ] ) )	{ $_REQUEST[ 'not_in__user_id' ] = array(); }
	if( ! in_array( 'system', $_REQUEST[ 'not_in__user_id' ], true ) ) { $_REQUEST[ 'not_in__user_id' ][] = 'system'; }
	foreach( $_REQUEST[ 'not_in__user_id' ] as $i => $user_id ) {
		echo '<input type="hidden" name="not_in__user_id[' . $i . ']" value="' . $user_id . '"/>';
	}
}
add_action( 'bookacti_before_booking_filters', 'bookacti_hide_system_bookings' );


/**
 * Hide events booked by "system" in calendar displaying booked events
 */
function bookacti_hide_system_booking_on_calendar( $query, $args ) {
	return substr_replace( $query, ' AND user_id != "system" ', strpos( $query, 'ORDER BY' ), 0 );
}
add_filter( 'bookacti_get_booked_events_query', 'bookacti_hide_system_booking_on_calendar', 10, 2 );

Vos catégories

Les nouveautés

Pour ELLE

Pour LUI