├── README.md
├── eventbrite-api-overview.png
├── eventbrite-api.php
├── inc
    ├── class-eventbrite-api.php
    ├── class-eventbrite-event.php
    ├── class-eventbrite-manager.php
    ├── class-eventbrite-query.php
    ├── class-eventbrite-requirements.php
    ├── class-eventbrite-templates.php
    └── functions.php
├── readme.txt
├── tmpl
    ├── compat
    │   ├── twentyeleven
    │   │   ├── eventbrite-index.php
    │   │   ├── eventbrite-single.php
    │   │   └── eventbrite-style.css
    │   ├── twentyfifteen
    │   │   ├── eventbrite-index.php
    │   │   ├── eventbrite-single.php
    │   │   └── eventbrite-style.css
    │   ├── twentyfourteen
    │   │   ├── eventbrite-index.php
    │   │   ├── eventbrite-single.php
    │   │   └── eventbrite-style.css
    │   ├── twentyten
    │   │   ├── eventbrite-index.php
    │   │   ├── eventbrite-single.php
    │   │   └── eventbrite-style.css
    │   ├── twentythirteen
    │   │   ├── eventbrite-index.php
    │   │   ├── eventbrite-single.php
    │   │   └── eventbrite-style.css
    │   └── twentytwelve
    │   │   ├── eventbrite-index.php
    │   │   ├── eventbrite-single.php
    │   │   └── eventbrite-style.css
    ├── eventbrite-index.php
    └── eventbrite-single.php
└── uninstall.php


/README.md:
--------------------------------------------------------------------------------
  1 | **Note: This plugin is not maintained, and relies on an Eventbrite endpoint that will cease to operate on February 20, 2020. See [this issue](https://github.com/Automattic/eventbrite-api/issues/83) for details and other options.**
  2 | 
  3 | # Eventbrite API WordPress Plugin
  4 | 
  5 | The Eventbrite API plugin brings the power of Eventbrite to WordPress, for both users and developers.
  6 | 
  7 | ## Overview
  8 | 
  9 | #### Users
 10 | 
 11 | By connecting to your [Eventbrite account](http://eventbrite.com/), events can be displayed directly on your WordPress.org website, complete with event details and ticket information. Events will blend in with the design of any theme, and events can be filtered by organizer or venue, just like post archives.
 12 | 
 13 | #### Developers
 14 | 
 15 | As a developer, you get simple-to-use tools for integrating Eventbrite into your themes or plugins. Use the helper functions to remove the complexity and heavy-lifting of API calls, and take advantage of assorted template tags for displaying various event information.
 16 | 
 17 | ## Requirements
 18 | 
 19 | #### Keyring
 20 | 
 21 | [Keyring](https://wordpress.org/plugins/keyring/) is required for the Eventbrite API plugin to work. Once it's installed with an active connection to Eventbrite, the Eventbrite API plugin will be able to display events.
 22 | 
 23 | If needed, admin notices will give helpful links and prompting to get Keyring and the Eventbrite API plugin up and running. These notices will appear on the Dashboard, PLugins, Tools, and Settings admin pages until issues are resolved.
 24 | 
 25 | ## Classes
 26 | 
 27 | ![Eventbrite API Classes Overview](https://raw.githubusercontent.com/Automattic/eventbrite-api/master/eventbrite-api-overview.png)
 28 | 
 29 | 
 30 | **`Eventbrite_API`**
 31 | 
 32 | * makes calls to the API
 33 | * handles option for the token
 34 | * defines supported endpoints
 35 | 
 36 | 
 37 | **`Eventbrite_Requirements`**
 38 | 
 39 | * ensures Keyring is installed, activated
 40 | * ensures an active Eventbrite connection
 41 | * provides admin notification prompts
 42 | 
 43 | 
 44 | **`Eventbrite_Manager`**
 45 | 
 46 | * uses `Eventbrite_API` to make API calls
 47 | * validates all query args and values to ensure no wasted API calls
 48 | * handles storing and returning transients
 49 | * prepares API results into the format needed by `Eventbrite_Event`
 50 | 
 51 | 
 52 | **`Eventbrite_Query`**
 53 | 
 54 | * like `WP_Query` for Eventbrite events (it extends `WP_Query`)
 55 | * creates a secondary loop
 56 | * supported arguments, passed as an array
 57 |   * `display_private`: (*boolean*) Include user events marked as Private. Default is `false`. Note that this changes the endpoint called from `event_search` to `user_owned_events`. See the [Eventbrite API docs](https://www.eventbrite.com/developer/v3/) for details.
 58 |   * `limit`: (*integer*) Return a maximum number of results.
 59 |   * `organizer_id`: (*integer*) Return only events for a certain organizer.
 60 |   * `p`: (*integer*) Get a single event.
 61 |   * `post__not_in`: (*array*) Remove certain events by ID from the results.
 62 |   * `venue_id`: (*integer*) Return only events for a certain venue.
 63 |   * `category_id`: (*integer*) Return only events for a certain category.
 64 |   * `subcategory_id`: (*integer*) Return only events for a certain subcategory.
 65 |   * `format_id`: (*integer*) Return only events for a certain format.
 66 | 
 67 | 
 68 | **`Eventbrite_Event`**
 69 | 
 70 | * like `WP_Post` for Eventbrite events
 71 | * does not extend `WP_Post`, as that class is marked `final`
 72 | * object properties
 73 |   * `ID` (*integer*)
 74 |   * `post_title` (*string*)
 75 |   * `post_content` (*string*)
 76 |   * `post_date` (*string*)
 77 |   * `post_date_gmt` (*string*)
 78 |   * `url` (*string*)
 79 |   * `logo_url` (*string*)
 80 |   * `start` (*object*)
 81 |   * `end` (*object*)
 82 |   * `organizer` (*object*)
 83 |   * `venue` (*object*)
 84 |   * `public` (*boolean*)
 85 |   * `tickets` (*object*)
 86 | 
 87 | **`Eventbrite_Templates`**
 88 | 
 89 | * extends the Template Hierarchy for handling Eventbrite templates
 90 | * adds rewrite rules for templates
 91 | 
 92 | ## Functions
 93 | 
 94 | #### Helper Functions
 95 | 
 96 | **`eventbrite_get_events( $params, $force )`**
 97 | 
 98 | * Get user-owned events (both public and private are returned by default).
 99 | * `$params`: (*array, optional*) [Accepted parameters and values](http://developer.eventbrite.com/docs/user-owned-events/)
100 | * `$force`: (*boolean, optional*) Force a fresh API call, ignoring any available transient. Default is `false`.
101 | 
102 | **`eventbrite_get_event( $id, $force )`**
103 | 
104 | * Retrieve a single user-owned event.
105 | * `$id`: (*integer, required*) Eventbrite event id
106 | * `$force`: (*boolean, optional*) Force a fresh API call, ignoring any available transient. Default is `false`.
107 | 
108 | **`eventbrite_search( $params, $force )`**
109 | 
110 | * Search all public Eventbrite events.
111 | * `$params`: (*array, optional*) [Accepted parameters and values](http://developer.eventbrite.com/docs/event-search/). Note that not passing any parameters, while technically valid, will usually result in timeout errors. Limiting the search to user-owned events can be done by passing `user.id => Eventbrite_API::$instance->get_token()->get_meta( 'user_id' )`.
112 | * `$force`: (*boolean, optional*) Force a fresh API call, ignoring any available transient. Default is `false`.
113 | 
114 | #### Template Tags
115 | 
116 | **`eventbrite_is_single( $query )`**
117 | 
118 | * Determine if we on an Eventbrite single view.
119 | * `$query`: (*object, optional*) Accepts an `Eventbrite_Query` object.
120 | * Returns: (*boolean*) `true` if the passed or current query is for an event single view, `false` otherwise.
121 | 
122 | **`eventbrite_is_event( $post )`**
123 | 
124 | * Check if a given or current post is an Eventbrite event.
125 | * `$post`: (*object or integer, optional*) Accepts a post/event object, or an ID.
126 | * Returns: (*boolean*) `true` if it's an Eventbrite_Event object or the ID of a valid event, `false` otherwise.
127 | 
128 | **`eventbrite_paging_nav( $events )`**
129 | 
130 | * Output pagination HTML for the index views.
131 | * Based on `wp_paginate_links()`.
132 | * `$events`: (*object, required*) Requires a valid `Eventbrite_Query` object. This avoids having to mess with the `$wp_query` object.
133 | 
134 | **`eventbrite_event_meta()`**
135 | 
136 | * Outputs meta information for an event: event time, venue, organizer, and a Details link to the event single view.
137 | * On the single view, the Details link goes to the event's page on eventbrite.com.
138 | 
139 | **`eventbrite_event_time()`**
140 | 
141 | * Output an event's local time, with date, starting, and end time.
142 | * Example: `December 8 2014, 7:00 PM - 10:00 PM`
143 | 
144 | **`eventbrite_event_venue()`**
145 | 
146 | * Access the current event's venue properties: `address`, `resource_uri`, `id`, `name`, `latitude`, `longitude`
147 | 
148 | **`eventbrite_event_organizer()`**
149 | 
150 | * Access the current event's organizer properties: `description`, `logo`, `resource_uri`, `id`, `name`, `url`, `num_past_events`, `num_future_events`
151 | 
152 | **`eventbrite_event_category()`**
153 | 
154 | * Access the current event's category properties: `resource_uri`, `id`, `name`, `name_localized`, `short_name`, `short_name_localized`
155 | 
156 | **`eventbrite_event_subcategory()`**
157 | 
158 | * Access the current event's subcategory properties: `resource_uri`, `id`, `name`, `name_localized`, `short_name`, `short_name_localized`
159 | 
160 | **`eventbrite_event_format()`**
161 | 
162 | * Access the current event's format properties: `resource_uri`, `id`, `name`, `name_localized`, `short_name`, `short_name_localized`
163 | 
164 | **`eventbrite_event_start()`**
165 | 
166 | * Access the current event's start time properties: `timezone`, `local`, `utc`
167 | 
168 | **`eventbrite_event_end()`**
169 | 
170 | * Access the current event's end time properties: `timezone`, `local`, `utc`
171 | 
172 | **`eventbrite_ticket_form_widget()`**
173 | 
174 | * Output ticket information by `<iframe>` with eventbrite.com's ticket form widget.
175 | * [Eventbrite widgets documentation](http://help.eventbrite.com/customer/en_us/portal/articles/428470-how-to-sell-eventbrite-tickets-registrations-on-your-website-using-embeddable-widgets)
176 | 
177 | **`eventbrite_ticket_form_widget_height()`**
178 | 
179 | * Calculates what height an event's ticket form `<iframe>` should be (pretty rough).
180 | * Height is calculated with a rough assortment of variables; [see here for details](https://github.com/Automattic/eventbrite-api/blob/master/inc/functions.php#L452).
181 | 
182 | **`eventbrite_event_eb_url()`**
183 | 
184 | * Get the URL to the current event on eventbrite.com.
185 | * Returns: (*string*) The eventbrite.com URL
186 | 
187 | **`eventbrite_is_multiday_event()`**
188 | 
189 | * Checks if the current event spans two or more calendar days (based on UTC time).
190 | * Returns: (*boolean*) `true` if the date is different for the start and end times, `false` if they're the same.
191 | 
192 | 
193 | ## Filters
194 | 
195 | **`eventbrite_templates`**
196 | 
197 | * Adjust the array of valid Eventbrite templates, used for determining body classes.
198 | 
199 | **`eventbrite_meta_separator`**
200 | 
201 | * Define the markup used to separate event meta.
202 | * Default: `<span class="sep"> &middot; </span>`
203 | 
204 | **`eventbrite_event_meta`**
205 | 
206 | * Filter the final HTML for an event's meta info.
207 | 
208 | **`eventbrite_paginate_links_args`**
209 | 
210 | * Adjust the arguments passed to the `paginate_links()` template tag (used by `eventbrite_paging_nav()`).
211 | 
212 | **`eventbrite_event_eb_url`**
213 | 
214 | * Filter an event's URL to its eventbrite.com page.
215 | 
216 | **`eventbrite_event_venue`**
217 | 
218 | * Modify the current event's venue properties (see template tag above).
219 | 
220 | **`eventbrite_event_organizer`**
221 | 
222 | * Modify the current event's organizer properties (see template tag above).
223 | 
224 | **`eventbrite_event_start`**
225 | 
226 | * Modify the current event's start time properties (see template tag above).
227 | 
228 | **`eventbrite_event_end`**
229 | 
230 | * Modify the current event's end time properties (see template tag above).
231 | 
232 | **`eventbrite_ticket_form_widget`**
233 | 
234 | * Filter the final HTML for the ticket form widgets.
235 | 
236 | **`eventbrite_ticket_form_widget_height`**
237 | 
238 | * Adjust the `<iframe>` height used when outputting a ticket form widget.
239 | 
240 | **`eventbrite_api_expansions`**
241 | 
242 | * Adjust the [expansions](https://www.eventbrite.com/developer/v3/reference/expansions/) requested on all API calls to Eventbrite.
243 | 


--------------------------------------------------------------------------------
/eventbrite-api-overview.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Automattic/eventbrite-api/a353ae251a7df46813f7fd2f63e4dcee70625130/eventbrite-api-overview.png


--------------------------------------------------------------------------------
/eventbrite-api.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | /*
 4 | Plugin Name: Eventbrite API
 5 | Plugin URI: https://github.com/Automattic/eventbrite-api
 6 | Description: A WordPress plugin that integrates the Eventbrite API with WordPress and Keyring.
 7 | Version: 1.0.11
 8 | Author: Automattic
 9 | Author URI: http://automattic.com
10 | License: GPL v2 or newer <https://www.gnu.org/licenses/gpl.txt>
11 | */
12 | 
13 | /**
14 |  * Set our token option on activation if an Eventbrite connection already exists in Keyring.
15 |  */
16 | function eventbrite_check_existing_token() {
17 | 	// Bail if Keyring isn't activated.
18 | 	if ( ! class_exists( 'Keyring_SingleStore' ) ) {
19 | 		return;
20 | 	}
21 | 
22 | 	// Get any Eventbrite tokens we may already have.
23 | 	$tokens = Keyring_SingleStore::init()->get_tokens( array( 'service'=>'eventbrite' ) );
24 | 
25 | 	// If we have one, just use the first.
26 | 	if ( ! empty( $tokens[0] ) ) {
27 | 		update_option( 'eventbrite_api_token', $tokens[0]->unique_id );
28 | 	}
29 | }
30 | register_activation_hook( __FILE__, 'eventbrite_check_existing_token' );
31 | 
32 | /**
33 |  * Load our API on top of the Keyring Eventbrite service.
34 |  */
35 | function eventbrite_api_load_keyring_service() {
36 | 	require_once( 'inc/class-eventbrite-api.php' );
37 | }
38 | add_action( 'keyring_load_services', 'eventbrite_api_load_keyring_service', 11 );
39 | 
40 | /**
41 |  * Load classes.
42 |  */
43 | function eventbrite_api_init() {
44 | 	// Load Eventbrite_Requirements.
45 | 	require_once( 'inc/class-eventbrite-requirements.php' );
46 | 
47 | 	// No point loading unless we have an active Eventbrite connection.
48 | 	if ( Eventbrite_Requirements::has_active_connection() ) {
49 | 		require_once( 'inc/class-eventbrite-manager.php' );
50 | 		require_once( 'inc/class-eventbrite-query.php' );
51 | 		require_once( 'inc/class-eventbrite-templates.php' );
52 | 		require_once( 'inc/class-eventbrite-event.php' );
53 | 		require_once( 'inc/functions.php' );
54 | 	}
55 | }
56 | add_action( 'init', 'eventbrite_api_init' );
57 | 


--------------------------------------------------------------------------------
/inc/class-eventbrite-api.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Eventbrite_API class, which interacts with the Keyring service to make the actual API requests to Eventbrite.
  4 |  *
  5 |  * @package Eventbrite_API
  6 |  */
  7 | 
  8 | // This plugin requires the Keyring plugin and its Eventbrite service.
  9 | if ( ! class_exists( 'Keyring_Service_Eventbrite' ) ) {
 10 | 	exit;
 11 | }
 12 | 
 13 | class Eventbrite_API extends Keyring_Service_Eventbrite {
 14 | 
 15 | 	static $instance;
 16 | 
 17 | 	/**
 18 | 	 * Constructor.
 19 | 	 */
 20 | 	function __construct() {
 21 | 		parent::__construct();
 22 | 
 23 | 		// Remove duplicate UI elements caused by constructors.
 24 | 		remove_action( 'keyring_eventbrite_manage_ui', array( $this, 'basic_ui' ) );
 25 | 		remove_filter( 'keyring_eventbrite_basic_ui_intro', array( $this, 'basic_ui_intro' ) );
 26 | 
 27 | 		self::$instance = $this;
 28 | 
 29 | 		$token = get_option( 'eventbrite_api_token' );
 30 | 		if ( ! empty( $token ) ) {
 31 | 			$this->set_token( Keyring::init()->get_token_store()->get_token( array( 'type' => 'access', 'id' => $token ) ) );
 32 | 		}
 33 | 		$this->define_endpoints();
 34 | 		add_action( 'keyring_connection_verified', array( $this, 'keyring_connection_verified' ), 10, 3 );
 35 | 		add_action( 'keyring_connection_deleted', array( $this, 'keyring_connection_deleted' ) );
 36 | 	}
 37 | 
 38 | 	/**
 39 | 	 * Get the user's API token.
 40 | 	 *
 41 | 	 * @access public
 42 | 	 *
 43 | 	 * @return string The user's token
 44 | 	 */
 45 | 	public function get_token() {
 46 | 		$token = get_option( 'eventbrite_api_token' );
 47 | 		if ( empty( $token ) )
 48 | 			return false;
 49 | 
 50 | 		$this->set_token( Keyring::init()->get_token_store()->get_token( array( 'type' => 'access', 'id' => $token ) ) );
 51 | 
 52 | 		$this->eventbrite_external_id = ( defined( 'IS_WPCOM' ) && IS_WPCOM ) ? $this->token->get_meta( 'external_id' ) : $this->token->get_meta( 'user_id' );
 53 | 
 54 | 		return $this->token;
 55 | 	}
 56 | 
 57 | 	/**
 58 | 	 * Define API endpoints.
 59 | 	 *
 60 | 	 * @access private
 61 | 	 */
 62 | 	private function define_endpoints() {
 63 | 		$token = self::$instance->get_token();
 64 | 		if ( empty( $token ) )
 65 | 			return;
 66 | 
 67 | 		$this->set_endpoint( 'user_owned_events', self::API_BASE . 'users/' . $this->eventbrite_external_id . '/owned_events', 'GET' );
 68 | 		$this->set_endpoint( 'event_details', self::API_BASE . 'events/', 'GET' );
 69 | 		$this->set_endpoint( 'event_search', self::API_BASE . 'events/search/', 'GET' );
 70 | 	}
 71 | 
 72 | 	/**
 73 | 	 * Make an API call.
 74 | 	 *
 75 | 	 * @access public
 76 | 	 *
 77 | 	 * @param  string $endpoint API endpoint supported by the plugin.
 78 | 	 * @param  array $query_params Parameters to be passed with the API call.
 79 | 	 * @param  integer $object_id Eventbrite event ID used when requesting a single event from the API.
 80 | 	 * @return object API response if successful, error (Keyring_Error or WP_Error) otherwise
 81 | 	 */
 82 | 	public static function call( $endpoint, $query_params = array(), $object_id = null ) {
 83 | 		$token = self::$instance->get_token();
 84 | 		if ( empty( $token ) )
 85 | 			return new Keyring_Error( '400', 'No token present for the Eventbrite API.' );
 86 | 
 87 | 		$endpoint_url = trailingslashit( self::$instance->{$endpoint . '_url'} );
 88 | 		$query_params['expand'] = apply_filters( 'eventbrite_api_expansions', 'logo,organizer,venue,ticket_classes,format,category,subcategory', $endpoint, $query_params, $object_id );
 89 | 		$method = self::$instance->{$endpoint . '_method'};
 90 | 		$params = array( 'method' => $method );
 91 | 
 92 | 		if ( ! empty( $object_id ) && is_numeric( $object_id ) ) {
 93 | 			$endpoint_url = trailingslashit( $endpoint_url . absint( $object_id ) );
 94 | 		}
 95 | 
 96 | 		if ( 'GET' == $method ) {
 97 | 			$endpoint_url = add_query_arg( $query_params, $endpoint_url );
 98 | 		} else if ( 'POST' == $method ) {
 99 | 			$params['body'] = $query_params;
100 | 		} else {
101 | 			return new WP_Error( '500', 'Method ' . $method . ' is not implemented in the Eventbrite API.' );
102 | 		}
103 | 		
104 | 		$response = self::$instance->request( $endpoint_url, $params );
105 | 
106 | 		return apply_filters( 'eventbrite_api_call_response', $response, $endpoint, $query_params, $object_id );
107 | 	}
108 | 
109 | 	/**
110 | 	 * Save the token for our Keyring connection.
111 | 	 *
112 | 	 * @param string $service The Keyring service being checked.
113 | 	 * @param int $id The current user's token.
114 | 	 * @param object $request_token Keyring_Request_Token object containing info required for the service's API call.
115 | 	 */
116 | 	function keyring_connection_verified( $service, $id, $request_token ) {
117 | 		if ( 'eventbrite' != $service || 'eventbrite' != $request_token->name ) {
118 | 			return;
119 | 		}
120 | 
121 | 		update_option( 'eventbrite_api_token', $id );
122 | 	}
123 | 
124 | 	/**
125 | 	 * Remove the stored token when the Keyring connection is lost.
126 | 	 *
127 | 	 * @param string $service The Keyring service connection being deleted.
128 | 	 */
129 | 	function keyring_connection_deleted( $service ) {
130 | 		if ( 'eventbrite' != $service ) {
131 | 			return;
132 | 		}
133 | 
134 | 		delete_option( 'eventbrite_api_token' );
135 | 	}
136 | 
137 | }
138 | 
139 | new Eventbrite_API;
140 | 


--------------------------------------------------------------------------------
/inc/class-eventbrite-event.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Eventbrite Event class.
  4 |  * Modeled on WP_Post, allowing developers to work with familiar terms and loop conventions.
  5 |  *
  6 |  * @package Eventbrite_API
  7 |  */
  8 | 
  9 | class Eventbrite_Event {
 10 | 
 11 | 	/**
 12 | 	 * Event ID.
 13 | 	 *
 14 | 	 * @var int
 15 | 	 */
 16 | 	public $ID; // id
 17 | 
 18 | 	/**
 19 | 	 * The event's title.
 20 | 	 *
 21 | 	 * @var string
 22 | 	 */
 23 | 	public $post_title; // name->text
 24 | 
 25 | 	/**
 26 | 	 * The event's content.
 27 | 	 *
 28 | 	 * @var string
 29 | 	 */
 30 | 	public $post_content; // description->html
 31 | 
 32 | 	/**
 33 | 	 * Date on which the event was created.
 34 | 	 *
 35 | 	 * @var string
 36 | 	 */
 37 | 	public $post_date; // created
 38 | 
 39 | 	/**
 40 | 	 * The event's Eventbrite.com URL.
 41 | 	 *
 42 | 	 * @var string
 43 | 	 */
 44 | 	public $url; // url
 45 | 
 46 | 	/**
 47 | 	 * The event's logo URL.
 48 | 	 *
 49 | 	 * @var string
 50 | 	 */
 51 | 	public $logo_url; // logo_url
 52 | 
 53 | 	/**
 54 | 	 * The event's UTC start time.
 55 | 	 *
 56 | 	 * @var string
 57 | 	 */
 58 | 	public $start; // start->utc
 59 | 
 60 | 	/**
 61 | 	 * The event's UTC end time.
 62 | 	 *
 63 | 	 * @var string
 64 | 	 */
 65 | 	public $end;  // start->utc
 66 | 
 67 | 	/**
 68 | 	 * The event organizer's name.
 69 | 	 *
 70 | 	 * @var string
 71 | 	 */
 72 | 	public $post_author; // organizer->name
 73 | 
 74 | 	/**
 75 | 	 * The event organizer's ID.
 76 | 	 *
 77 | 	 * @var int
 78 | 	 */
 79 | 	public $organizer_id; // organizer->id
 80 | 
 81 | 	/**
 82 | 	 * The event's venue.
 83 | 	 *
 84 | 	 * @var string
 85 | 	 */
 86 | 	public $venue;  // venue->name
 87 | 
 88 | 	/**
 89 | 	 * The venue's ID.
 90 | 	 *
 91 | 	 * @var int
 92 | 	 */
 93 | 	public $venue_id; // venue->id
 94 | 
 95 | 	/**
 96 | 	 * The event's subcategory.
 97 | 	 *
 98 | 	 * @var string
 99 | 	 */
100 | 	public $subcategory;  // subcategory->name
101 | 
102 | 	/**
103 | 	 * The event's category.
104 | 	 *
105 | 	 * @var string
106 | 	 */
107 | 	public $category;  // category->name
108 | 
109 | 	/**
110 | 	 * The event's format.
111 | 	 *
112 | 	 * @var string
113 | 	 */
114 | 	public $format;  // format->name
115 | 
116 | 	/**
117 | 	 * Retrieve Eventbrite_Event instance.
118 | 	 *
119 | 	 * @static
120 | 	 * @access public
121 | 	 *
122 | 	 * @param int $event_id Event ID on eventbrite.com (commonly ten digits).
123 | 	 * @return Eventbrite_Event|bool Eventbrite_Event object, false otherwise.
124 | 	 */
125 | 	public static function get_instance( $event_id ) {
126 | 		// We can bail if no event ID was passed, or it wasn't an integer.
127 | 		if ( ! $event_id || ! is_int( $event_id ) ) {
128 | 			return false;
129 | 		}
130 | 
131 | 		// Get the raw event.
132 | 		$event = eventbrite_get_event( $event_id );
133 | 
134 | 		// Return false if the ID was invalid or we got an error from the API call.
135 | 		if ( ! $event || ! empty( $event->error ) ) {
136 | 			return false;
137 | 		}
138 | 
139 | 		// We've got an event, let's dress it up.
140 | 		return new Eventbrite_Event( $event->events[0] );
141 | 	}
142 | 
143 | 	/**
144 | 	 * Constructor.
145 | 	 *
146 | 	 * @access public
147 | 	 *
148 | 	 * @param object $event An event object from the API results.
149 | 	 */
150 | 	public function __construct( $event ) {
151 | 		foreach ( get_object_vars( $event ) as $key => $value ) {
152 | 			$this->$key = $value;
153 | 		}
154 | 	}
155 | }
156 | 


--------------------------------------------------------------------------------
/inc/class-eventbrite-manager.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Eventbrite Manager class for handling calls to the Eventbrite API.
  4 |  *
  5 |  * @package Eventbrite_API
  6 |  */
  7 | 
  8 | class Eventbrite_Manager {
  9 | 	/**
 10 | 	 * Class instance used by themes and plugins.
 11 | 	 *
 12 | 	 * @var object
 13 | 	 */
 14 | 	public static $instance;
 15 | 
 16 | 	/**
 17 | 	 * The class constructor.
 18 | 	 *
 19 | 	 * @access public
 20 | 	 */
 21 | 	public function __construct() {
 22 | 		// Assign our instance.
 23 | 		self::$instance = $this;
 24 | 
 25 | 		// Add hooks.
 26 | 		add_action( 'keyring_connection_deleted', array( $this, 'flush_transients' ), 10, 2 );
 27 | 	}
 28 | 
 29 | 	/**
 30 | 	 * Make a call to the Eventbrite v3 REST API, or return an existing transient.
 31 | 	 *
 32 | 	 * @access public
 33 | 	 *
 34 | 	 * @param string $endpoint Valid Eventbrite v3 API endpoint.
 35 | 	 * @param array $params Parameters passed to the API during a call.
 36 | 	 * @param int|string|bool $id A specific event ID used for calls to the event_details endpoint.
 37 | 	 * @param bool $force Force a fresh API call, ignoring any existing transient.
 38 | 	 * @return object Request results
 39 | 	 */
 40 | 	public function request( $endpoint, $params = array(), $id = false, $force = false ) {
 41 | 		// Make sure the endpoint and parameters are valid.
 42 | 		if ( ! $this->validate_endpoint_params( $endpoint, $params ) ) {
 43 | 			return false;
 44 | 		}
 45 | 
 46 | 		// If an ID has been passed, validate and sanitize it.
 47 | 		if ( ! empty( $id ) && is_numeric( $id ) && ( 0 < absint( $id ) ) ) {
 48 | 			$id = absint( $id );
 49 | 		} else {
 50 | 			$id = false;
 51 | 		}
 52 | 
 53 | 		// Return a cached result if we have one.
 54 | 		if ( ! $force ) {
 55 | 			$cached = $this->get_cache( $endpoint, $params );
 56 | 			if ( ! empty( $cached ) ) {
 57 | 				return $cached;
 58 | 			}
 59 | 		}
 60 | 
 61 | 		// Extend the HTTP timeout to account for Eventbrite API calls taking longer than ~5 seconds.
 62 | 		add_filter( 'http_request_timeout', array( $this, 'increase_timeout' ) );
 63 | 
 64 | 		// Make a fresh request.
 65 | 		$request = Eventbrite_API::call( $endpoint, $params, $id );
 66 | 
 67 | 		// Remove the timeout extension for any non-Eventbrite calls.
 68 | 		remove_filter( 'http_request_timeout', array( $this, 'increase_timeout' ) );
 69 | 
 70 | 		// If we get back a proper response, cache it.
 71 | 		if ( ! is_wp_error( $request ) ) {
 72 | 			$transient_name = $this->get_transient_name( $endpoint, $params );
 73 | 			set_transient( $transient_name, $request, apply_filters( 'eventbrite_cache_expiry', DAY_IN_SECONDS ) );
 74 | 			$this->register_transient( $transient_name );
 75 | 		}
 76 | 
 77 | 		return $request;
 78 | 	}
 79 | 
 80 | 	/**
 81 | 	 * Validate the given parameters against its endpoint. Values are also validated where the API only accepts
 82 | 	 * specific values.
 83 | 	 *
 84 | 	 * @access protected
 85 | 	 *
 86 | 	 * @param string $endpoint Endpoint to be called.
 87 | 	 * @param array $params Parameters to be passed during the API call.
 88 | 	 * @return bool True if all params were able to be validated, false otherwise.
 89 | 	 */
 90 | 	protected function validate_endpoint_params( $endpoint, $params ) {
 91 | 		// Get valid request params.
 92 | 		$valid = $this->get_endpoint_params();
 93 | 
 94 | 		// Validate the endpoint.
 95 | 		if ( ! array_key_exists( $endpoint, $valid ) ) {
 96 | 			return false;
 97 | 		}
 98 | 
 99 | 		// Check that an array was passed for params.
100 | 		if ( ! is_array( $params ) ) {
101 | 			return false;
102 | 		}
103 | 
104 | 		// Giving no parameters at all for queries is fine.
105 | 		if ( empty( $params ) ) {
106 | 			return true;
107 | 		}
108 | 
109 | 		// The 'page' parameter is valid for any endpoint, as long as it's a positive integer.
110 | 		if ( isset( $params['page'] ) && ( 1 > (int) $params['page'] ) ) {
111 | 			return false;
112 | 		}
113 | 		unset( $params['page'] );
114 | 
115 | 		// Compare each passed parameter and value against our valid ones, and fail if a match can't be found.
116 | 		foreach ( $params as $key => $value ) {
117 | 			// Check the parameter is valid for that endpoint.
118 | 			if ( ! array_key_exists( $key, $valid[$endpoint] ) ) {
119 | 				return false;
120 | 			}
121 | 
122 | 			// If the parameter has a defined set of possible values, make sure the passed value is valid.
123 | 			if ( ! empty( $valid[$endpoint][$key] ) && ! in_array( $value, $valid[$endpoint][$key] ) ) {
124 | 				return false;
125 | 			}
126 | 		}
127 | 
128 | 		// Looks good.
129 | 		return true;
130 | 	}
131 | 
132 | 	/**
133 | 	 * Search for public live events.
134 | 	 *
135 | 	 * @access public
136 | 	 *
137 | 	 * @param array $params Parameters to be passed during the API call.
138 | 	 * @param bool $force Force a fresh API call, ignoring any existing transient.
139 | 	 * @return object Eventbrite_Manager
140 | 	 */
141 | 	public function do_event_search( $params = array(), $force = false ) {
142 | 		// Get the raw results.
143 | 		$results = $this->request( 'event_search', $params, false, $force );
144 | 
145 | 		// If we have events, there's some work to do.
146 | 		if ( ! empty( $results->events ) ) {
147 | 			// Add the missing 'listed' property. Because this endpoint only returns public events, the API doesn't include it – but we need it.
148 | 			foreach ( $results->events as $event ) {
149 | 				$event->listed = true;
150 | 			}
151 | 
152 | 			// Map events to the format expected by Eventbrite_Event.
153 | 			$results->events = array_map( array( $this, 'map_event_keys' ), $results->events );
154 | 		}
155 | 
156 | 		return $results;
157 | 	}
158 | 
159 | 	/**
160 | 	 * Get user-owned private and public events.
161 | 	 *
162 | 	 * @access public
163 | 	 *
164 | 	 * @param array $params Parameters to be passed during the API call.
165 | 	 * @param bool $force Force a fresh API call, ignoring any existing transient.
166 | 	 * @return object Eventbrite_Manager
167 | 	 */
168 | 	public function get_user_owned_events( $params = array(), $force = false ) {
169 | 		// Query for 'live' events by default (rather than 'all', which includes events in the past).
170 | 		if ( ! isset( $params['status'] ) ) {
171 | 			$params['status'] = 'live';
172 | 		}
173 | 
174 | 		// Get the raw results.
175 | 		$results = $this->request( 'user_owned_events', $params, false, $force );
176 | 
177 | 		// If we have events, map them to the format expected by Eventbrite_Event
178 | 		if ( ! empty( $results->events ) ) {
179 | 			$results->events = array_map( array( $this, 'map_event_keys' ), $results->events );
180 | 		}
181 | 
182 | 		return $results;
183 | 	}
184 | 
185 | 	/**
186 | 	 * Get a single event by ID.
187 | 	 *
188 | 	 * @access public
189 | 	 *
190 | 	 * @param int|string|bool $id Eventbrite event ID (commonly a ten digit integer).
191 | 	 * @param bool $force Force a fresh API call, ignoring any existing transient.
192 | 	 * @return object Eventbrite_Manager
193 | 	 */
194 | 	public function get_event( $id = false, $force = false ) {
195 | 		// Ensure ID is an integer of at least 10 digits.
196 | 		if ( ! is_numeric( $id ) || 10 > strlen( $id ) ) {
197 | 			return false;
198 | 		}
199 | 
200 | 		// Get the raw results. Although query parameters aren't needed for the API call, they're necessary for identifying transients.
201 | 		$results = $this->request( 'event_details', array( 'p' => absint( $id ) ), absint( $id ), $force );
202 | 
203 | 		// If we have our event, map it to the format expected by Eventbrite_Event, and create pagination info.
204 | 		if ( empty( $results->error ) ) {
205 | 			$results = (object) array(
206 | 				'events' => array(
207 | 					$this->map_event_keys( $results ),
208 | 				),
209 | 				'pagination' => (object) array(
210 | 					'object_count' => 1,
211 | 					'page_number'  => 1,
212 | 					'page_size'    => 1,
213 | 					'page_count'   => 1,
214 | 				),
215 | 			);
216 | 		}
217 | 
218 | 		return $results;
219 | 	}
220 | 
221 | 	/**
222 | 	 * Get the transient for a certain endpoint and combination of parameters.
223 | 	 * get_transient() returns false if not found.
224 | 	 *
225 | 	 * @access protected
226 | 	 *
227 | 	 * @param string $endpoint Endpoint being called.
228 | 	 * @param array $params Parameters to be passed during the API call.
229 | 	 * @return mixed Transient if found, false if not.
230 | 	 */
231 | 	protected function get_cache( $endpoint, $params ) {
232 | 		return get_transient( $this->get_transient_name( $endpoint, $params ) ); 
233 | 	}
234 | 
235 | 	/**
236 | 	 * Determine a transient's name based on endpoint and parameters.
237 | 	 *
238 | 	 * @access protected
239 | 	 *
240 | 	 * @param string $endpoint Endpoint being called.
241 | 	 * @param array $params Parameters to be passed during the API call.
242 | 	 * @return string
243 | 	 */
244 | 	protected function get_transient_name( $endpoint, $params ) {
245 | 		// Results in 62 characters for the timeout option name (maximum is 64).
246 | 		$transient_name = 'eventbrite_' . md5( $endpoint . implode( $params ) );
247 | 
248 | 		return apply_filters( 'eventbrite_transient_name', $transient_name, $endpoint, $params );
249 | 	}
250 | 
251 | 	/**
252 | 	 * Return an array of valid request parameters by endpoint.
253 | 	 *
254 | 	 * @access protected
255 | 	 *
256 | 	 * @return array All valid request parameters for supported endpoints.
257 | 	 */
258 | 	protected function get_endpoint_params() {
259 | 		$params = array(
260 | 			// http://developer.eventbrite.com/docs/event-search/
261 | 			'event_search' => array(
262 | 				'q'                         => array(),
263 | 				'since_id'                  => array(),
264 | 				'sort_by'                   => array(
265 | 					'id',
266 | 					'date',
267 | 					'name',
268 | 					'city',
269 | 				),
270 | 				'popular'                   => array(
271 | 					true,
272 | 					false,
273 | 				),
274 | 				'location.address'          => array(),
275 | 				'location.latitude'         => array(),
276 | 				'location.longitude'        => array(),
277 | 				'location.within'           => array(),
278 | 				'venue.city'                => array(),
279 | 				'venue.region'              => array(),
280 | 				'venue.country'             => array(),
281 | 				'organizer.id'              => array(),
282 | 				'user.id'                   => array(),
283 | 				'tracking_code'             => array(),
284 | 				'categories'                => array(),
285 | 				'formats'                   => array(),
286 | 				'start_date.range_start'    => array(),
287 | 				'start_date.range_end'      => array(),
288 | 				'start_date.keyword'        => array(
289 | 					'today',
290 | 					'tomorrow',
291 | 					'this_week',
292 | 					'this_weekend',
293 | 					'next_week',
294 | 					'this_month',
295 | 				),
296 | 				'date_created.range_start'  => array(),
297 | 				'date_created.range_end'    => array(),
298 | 				'date_created.keyword'      => array(
299 | 					'today',
300 | 					'tomorrow',
301 | 					'this_week',
302 | 					'this_weekend',
303 | 					'next_week',
304 | 					'this_month',
305 | 				),
306 | 				'date_modified.range_start' => array(),
307 | 				'date_modified.range_end'   => array(),
308 | 				'date_modified.keyword'     => array(
309 | 					'today',
310 | 					'tomorrow',
311 | 					'this_week',
312 | 					'this_weekend',
313 | 					'next_week',
314 | 					'this_month',
315 | 				),
316 | 			),
317 | 			// http://developer.eventbrite.com/docs/event-details/
318 | 			'event_details' => array(
319 | 				// Not a true param for this endpoint; the ID gets passed as its own argument in the API call.
320 | 				'p' => array(),
321 | 			),
322 | 			// http://developer.eventbrite.com/docs/user-owned-events/
323 | 			'user_owned_events' => array(
324 | 				'status'   => array(
325 | 					'all',
326 | 					'cancelled',
327 | 					'draft',
328 | 					'ended',
329 | 					'live',
330 | 					'started',
331 | 				),
332 | 				'order_by' => array(
333 | 					'start_asc',
334 | 					'start_desc',
335 | 					'created_asc',
336 | 					'created_desc',
337 | 				),
338 | 			),
339 | 		);
340 | 
341 | 		return $params;
342 | 	}
343 | 
344 | 	/**
345 | 	 * Convert the Eventbrite API properties into properties used by Eventbrite_Event.
346 | 	 *
347 | 	 * @access protected
348 | 	 *
349 | 	 * @param object $api_event A single event from the API results.
350 | 	 * @return object Event with Eventbrite_Event keys.
351 | 	 */
352 | 	protected function map_event_keys( $api_event ) {
353 | 		$event = array();
354 | 
355 | 		$event['ID']            = ( isset( $api_event->id ) )                ? $api_event->id                : '';
356 | 		$event['post_title']    = ( isset( $api_event->name->text ) )        ? $api_event->name->text        : '';
357 | 		$event['post_content']  = ( isset( $api_event->description->html ) ) ? $api_event->description->html : '';
358 | 		$event['post_date']     = ( isset( $api_event->start->local ) )      ? $api_event->start->local      : '';
359 | 		$event['post_date_gmt'] = ( isset( $api_event->start->utc ) )        ? $api_event->start->utc        : '';
360 | 		$event['url']           = ( isset( $api_event->url ) )               ? $api_event->url               : '';
361 | 		$event['logo_url']      = ( isset( $api_event->logo->url ) )         ? $api_event->logo->url         : '';
362 | 		$event['logo']          = ( isset( $api_event->logo ) )              ? $api_event->logo              : '';
363 | 		$event['start']         = ( isset( $api_event->start ) )             ? $api_event->start             : '';
364 | 		$event['end']           = ( isset( $api_event->end ) )               ? $api_event->end               : '';
365 | 		$event['organizer']     = ( isset( $api_event->organizer ) )         ? $api_event->organizer         : '';
366 | 		$event['venue']         = ( isset( $api_event->venue ) )             ? $api_event->venue             : '';
367 | 		$event['public']        = ( isset( $api_event->listed ) )            ? $api_event->listed            : '';
368 | 		$event['tickets']       = ( isset( $api_event->ticket_classes ) )    ? $api_event->ticket_classes    : '';
369 | 		$event['category']      = ( isset( $api_event->category ) )          ? $api_event->category          : '';
370 | 		$event['subcategory']   = ( isset( $api_event->subcategory ) )       ? $api_event->subcategory       : '';
371 | 		$event['format']        = ( isset( $api_event->format ) )            ? $api_event->format            : '';
372 | 
373 | 		return (object) $event;
374 | 	}
375 | 
376 | 	/**
377 | 	 * Add a transient name to the list of registered transients, stored in the 'eventbrite_api_transients' option.
378 | 	 *
379 | 	 * @access protected
380 | 	 *
381 | 	 * @param string $transient_name The transient name/key used to store the transient.
382 | 	 */
383 | 	protected function register_transient( $transient_name ) {
384 | 		// Get any existing list of transients.
385 | 		$transients = get_option( 'eventbrite_api_transients', array() );
386 | 
387 | 		// Add the new transient if it doesn't already exist.
388 | 		if ( ! in_array( $transient_name, $transients ) ) {
389 | 			$transients[] = $transient_name;
390 | 		}
391 | 
392 | 		// Save the updated list of transients.
393 | 		update_option( 'eventbrite_api_transients', $transients );
394 | 	}
395 | 
396 | 	/**
397 | 	 * Flush all transients.
398 | 	 *
399 | 	 * @access public
400 | 	 *
401 | 	 * @param string $service The Keyring service that has lost its connection.
402 | 	 * @param string $request The Keyring action that's been called ("delete", not used).
403 | 	 */
404 | 	public function flush_transients( $service, $request ) {
405 | 		// Bail if it wasn't an Eventbrite connection that got deleted.
406 | 		if ( 'eventbrite' != $service ) {
407 | 			return;
408 | 		}
409 | 
410 | 		// Get the list of registered transients.
411 | 		$transients = get_option( 'eventbrite_api_transients', array() );
412 | 
413 | 		// Bail if we have no transients.
414 | 		if ( ! $transients ) {
415 | 			return;
416 | 		}
417 | 
418 | 		// Loop through all registered transients, deleting each one.
419 | 		foreach ($transients as $transient ) {
420 | 			delete_transient( $transient );
421 | 		}
422 | 
423 | 		// Reset the list of registered transients.
424 | 		delete_option( 'eventbrite_api_transients' );
425 | 	}
426 | 
427 | 	/**
428 | 	 * Increase the timeout for Eventbrite API calls from the default 5 seconds to 15.
429 | 	 *
430 | 	 * @access public
431 | 	 */
432 | 	public function increase_timeout() {
433 | 		return 15;
434 | 	}
435 | }
436 | 
437 | new Eventbrite_Manager;
438 | 
439 | /**
440 |  * Allow themes and plugins a simple function to access Eventbrite_Manager methods and properties.
441 |  *
442 |  * @return object Eventbrite_Manager
443 |  */
444 | function eventbrite() {
445 | 	return Eventbrite_Manager::$instance;
446 | }
447 | 


--------------------------------------------------------------------------------
/inc/class-eventbrite-query.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Eventbrite Query class.
  4 |  * Modeled on and extends WP_Query, allowing developers to work with familiar terms and loop conventions.
  5 |  *
  6 |  * @package Eventbrite_API
  7 |  */
  8 | 
  9 | class Eventbrite_Query extends WP_Query {
 10 | 	/**
 11 | 	 * Results from the API call. Includes up to 50 objects plus pagination info.
 12 | 	 *
 13 | 	 * @var object
 14 | 	 */
 15 | 	protected $api_results;
 16 | 
 17 | 	/**
 18 | 	 * Constructor.
 19 | 	 *
 20 | 	 * Sets up the Eventbrite query.
 21 | 	 *
 22 | 	 * @access public
 23 | 	 *
 24 | 	 * @param string $query URL query string.
 25 | 	 */
 26 | 	public function __construct( $query = '' ) {
 27 | 		// Process any query args from the URL.
 28 | 		$query = $this->process_query_args( $query );
 29 | 		// Assign hooks.
 30 | 		add_filter( 'post_link', array( $this, 'filter_event_permalink' ) );
 31 | 		add_filter( 'get_post_metadata', array( $this, 'filter_post_metadata' ), 10, 3 );
 32 | 		add_filter( 'post_thumbnail_html', array( $this, 'filter_event_logo' ), 9, 2 );
 33 | 		add_filter( 'post_class', array( $this, 'filter_post_classes' ) );
 34 | 		add_filter( 'author_link', array( $this, 'filter_author_url' ) );
 35 | 		add_filter( 'the_author', array( $this, 'filter_author_name' ) );
 36 | 		remove_filter( 'the_content', 'wpautop' );
 37 | 
 38 | 		// Put our query in motion.
 39 | 		$this->query( $query );
 40 | 	}
 41 | 
 42 | 	/**
 43 | 	 * Handle any query args that come from the requested URL.
 44 | 	 *
 45 | 	 * @access protected
 46 | 	 *
 47 | 	 * @param  mixed $query Query string.
 48 | 	 * @return array Query arguments
 49 | 	 */
 50 | 	protected function process_query_args( $query ) {
 51 | 		// Handle requests for paged events.
 52 | 		$paged = get_query_var( 'paged' );
 53 | 		if ( 2 <= $paged ) {
 54 | 			$query['paged'] = $paged;
 55 | 		}
 56 | 
 57 | 		// Filter by organizer ID if an "author archive" (organizer events) was requested.
 58 | 		$organizer_id = get_query_var( 'organizer_id' );
 59 | 		if ( empty( $query['organizer_id'] ) && ! empty( $organizer_id ) ) {
 60 | 			$query['organizer_id'] = (int) $organizer_id;
 61 | 		}
 62 | 
 63 | 		// Filter by venue ID if a venue archive (all events at a certain venue) was requested.
 64 | 		$venue_id = get_query_var( 'venue_id' );
 65 | 		if ( empty( $query['venue_id'] ) && ! empty( $venue_id ) ) {
 66 | 			$query['venue_id'] = (int) $venue_id;
 67 | 		}
 68 | 
 69 | 		// Filter by category ID if a category archive (all events in a certain category) was requested.
 70 | 		$category_id = get_query_var( 'category_id' );
 71 | 		if ( empty( $query['category_id'] ) && ! empty( $category_id ) ) {
 72 | 			$query['category_id'] = (int) $category_id;
 73 | 		}
 74 | 
 75 | 		// Filter by subcategory ID if a subcategory archive (all events in a certain subcategory) was requested.
 76 | 		$subcategory_id = get_query_var( 'subcategory_id' );
 77 | 		if ( empty( $query['subcategory_id'] ) && ! empty( $subcategory_id ) ) {
 78 | 			$query['subcategory_id'] = (int) $subcategory_id;
 79 | 		}
 80 | 
 81 | 		// Filter by format ID if a format archive (all events in a certain format) was requested.
 82 | 		$format_id = get_query_var( 'format_id' );
 83 | 		if ( empty( $query['format_id'] ) && ! empty( $format_id ) ) {
 84 | 			$query['format_id'] = (int) $format_id;
 85 | 		}
 86 | 
 87 | 		return $query;
 88 | 	}
 89 | 
 90 | 	/**
 91 | 	 * Retrieve the posts based on query variables.
 92 | 	 *
 93 | 	 * @access public
 94 | 	 *
 95 | 	 * @return array List of posts.
 96 | 	 */
 97 | 	public function get_posts() {
 98 | 		// Set up query variables.
 99 | 		$this->parse_query();
100 | 
101 | 		// Restore `paged` if changed to `page` (in the case of index pagination).
102 | 		if ( ! empty( $this->query_vars['page'] ) ) {
103 | 			$this->query_vars['paged'] = $this->query_vars['page'];
104 | 			unset( $this->query_vars['page'] );
105 | 		}
106 | 
107 | 		// Set any required parameters for the API request based on the query vars.
108 | 		$params = $this->set_api_params();
109 | 
110 | 		// Determine which endpoint is needed. Do we want just a single event?
111 | 		if ( ! empty( $this->query_vars['p'] ) ) {
112 | 			$this->api_results = eventbrite()->get_event( $this->query_vars['p'] );
113 | 		}
114 | 
115 | 		// If private events are wanted, the user_owned_events endpoint must be used.
116 | 		elseif ( isset( $this->query_vars['display_private'] ) && true === $this->query_vars['display_private'] ) {
117 | 			$this->api_results = eventbrite()->get_user_owned_events( $params );
118 | 		}
119 | 
120 | 		// It's a run-of-the-mill query (only the user's public live events), meaning event_search is best.
121 | 		else {
122 | 			$this->api_results = eventbrite()->do_event_search( $params );
123 | 		}
124 | 
125 | 		// Do any post-API query processing.
126 | 		$this->post_api_filters();
127 | 
128 | 		// Set properties based on the results.
129 | 		$this->set_properties();
130 | 
131 | 		// Return what we have for posts.
132 | 		return $this->posts;
133 | 	}
134 | 
135 | 	/**
136 | 	 * Determine parameters for an API call.
137 | 	 *
138 | 	 * @access protected
139 | 	 *
140 | 	 * @return array API call parameters
141 | 	 */
142 | 	protected function set_api_params() {
143 | 		$params = array();
144 | 
145 | 		// Add 'page' parameter if we need events above the first 50.
146 | 		if ( 5 < $this->query_vars['paged'] ) {
147 | 			/**
148 | 			 * The API returns pages of 50, and we currently only support a fixed number of 10 events per WordPress page.
149 | 			 */
150 | 			$params['page'] = ceil( $this->query_vars['paged'] / 5 );
151 | 		}
152 | 
153 | 		// We need the Eventbrite user ID (or an organizer) if we're getting only public events.
154 | 		if ( ! isset( $this->query_vars['display_private'] ) || true !== $this->query_vars['display_private'] ) {
155 | 			// Set sorting.
156 | 			$params['sort_by'] = 'date';
157 | 
158 | 			// Set the user ID if we don't have a specified organizer.
159 | 			if ( ! empty( $this->query_vars['organizer_id'] ) ) {
160 | 				$params['organizer.id'] = (int) $this->query_vars['organizer_id'];
161 | 			} else {
162 | 				$params['user.id'] = Eventbrite_API::$instance->eventbrite_external_id;
163 | 			}
164 | 		}
165 | 
166 | 		// Adjust status for private events if necessary.
167 | 		if ( isset( $this->query_vars['display_private'] ) && true === $this->query_vars['display_private'] && ! empty( $this->query_vars['status'] ) ) {
168 | 			$params['status'] = $this->query_vars['status'];
169 | 		}
170 | 
171 | 		return $params;
172 | 	}
173 | 
174 | 	/**
175 | 	 * Set properties based on the fully processed results.
176 | 	 *
177 | 	 * @access protected
178 | 	 */
179 | 	protected function set_properties() {
180 | 		if ( empty( $this->api_results->events ) ) {
181 | 			$this->posts = array();
182 | 		} else {
183 | 			// Set found_posts based on all posts returned after Eventbrite_Query filtering.
184 | 			$this->found_posts = ( isset( $this->query_vars['limit'] ) && ( $this->query_vars['limit'] < $this->api_results->pagination->object_count ) ) ? count( $this->api_results->events ) : $this->api_results->pagination->object_count;
185 | 
186 | 			// Return all posts if `nopaging` is true (maximum of 50).
187 | 			if ( isset( $this->query_vars['nopaging'] ) && true === $this->query_vars['nopaging'] ) {
188 | 				$this->posts = array_slice( $this->api_results->events, 0, $this->found_posts );
189 | 				$posts_per_page = count( $this->posts );
190 | 			}
191 | 
192 | 			// Determine posts according to any pagination querying. Math hurts.
193 | 			else {
194 | 				$modulus = ( 2 <= $this->query_vars['paged'] && 0 == $this->query_vars['paged'] % 5 ) ? 5 : $this->query_vars['paged'] % 5;
195 | 				$offset = ( 2 <= $modulus && 5 >= $modulus ) ? ( $modulus - 1 ) * 10 : 0;
196 | 				$this->posts = array_slice( $this->api_results->events, $offset, 10 );
197 | 				$posts_per_page = 10;
198 | 			}
199 | 
200 | 			// Turn the posts into Eventbrite_Event objects.
201 | 			$this->posts = array_map( array( $this, 'create_eventbrite_event' ), $this->posts );
202 | 
203 | 			// Determine the maximum number of pages.
204 | 			$this->post_count = count( $this->posts );
205 | 			$this->max_num_pages = ceil( $this->found_posts / $posts_per_page );
206 | 
207 | 			// Set the first post.
208 | 			$this->post = reset( $this->posts );
209 | 		}
210 | 
211 | 		// Adjust some WP_Query parsing.
212 | 		if ( ! empty( $this->query_vars['p'] ) ) {
213 | 			$this->is_single = true;
214 | 		} else {
215 | 			$this->is_category = true;
216 | 			$this->is_archive = true;
217 | 			$this->is_page = false;
218 | 		}
219 | 		$this->is_home = false;
220 | 	}
221 | 
222 | 	/**
223 | 	 * Turn a given event into a proper Eventbrite_Event object.
224 | 	 *
225 | 	 * @access protected
226 | 	 *
227 | 	 * @param  null|object $event An event object from the API results.
228 | 	 * @return object Eventbrite_Event object.
229 | 	 */
230 | 	protected function create_eventbrite_event( $event = null ) {
231 | 		// Bail if nothing is passed in.
232 | 		if ( empty( $event ) ) {
233 | 			return null;
234 | 		}
235 | 
236 | 		if ( is_a( $event, 'Eventbrite_Event' ) ) {
237 | 			// We already have an Eventbrite_Event object. Nothing to do here.
238 | 			$_event = $event;
239 | 		} elseif ( is_object( $event ) ) {
240 | 			// Looks like we have an object already, so make it an Eventbrite_Event object.
241 | 			$_event = new Eventbrite_Event( $event );
242 | 		} else {
243 | 			// Just an ID was passed in. Let's go get the event.
244 | 			$_event = Eventbrite_Event::get_instance( $event );
245 | 		}
246 | 
247 | 		// That was a bust. We've got nothing.
248 | 		if ( ! $_event ) {
249 | 			return null;
250 | 		}
251 | 
252 | 		// Return our Eventbrite_Event object.
253 | 		return $_event;
254 | 	}
255 | 
256 | 	/**
257 | 	 * Process any remaining internal query parameters. These are parameters that are specific to Eventbrite_Query, not the API calls.
258 | 	 *
259 | 	 * @access protected
260 | 	 */
261 | 	protected function post_api_filters() {
262 | 		// Do nothing if API results were empty, false, or an error.
263 | 		if ( empty( $this->api_results ) || is_wp_error( $this->api_results ) ) {
264 | 			return false;
265 | 		}
266 | 
267 | 		// Filter out specified IDs: 'post__not_in'
268 | 		if ( isset( $this->query_vars['post__not_in'] ) && is_array( $this->query_vars['post__not_in'] ) ) {
269 | 			$this->api_results->events = array_filter( $this->api_results->events, array( $this, 'filter_by_post_not_in' ) );
270 | 		}
271 | 
272 | 		// Filter by organizer: 'organizer_id'
273 | 		if ( isset( $this->query_vars['organizer_id'] ) && is_integer( $this->query_vars['organizer_id'] ) ) {
274 | 			$this->api_results->events = array_filter( $this->api_results->events, array( $this, 'filter_by_organizer' ) );
275 | 		}
276 | 
277 | 		// Filter by venue: 'venue_id'
278 | 		if ( isset( $this->query_vars['venue_id'] ) && is_integer( $this->query_vars['venue_id'] ) ) {
279 | 			$this->api_results->events = array_filter( $this->api_results->events, array( $this, 'filter_by_venue' ) );
280 | 		}
281 | 
282 | 		// Filter by category: 'category_id'
283 | 		if ( isset( $this->query_vars['category_id'] ) && is_integer( $this->query_vars['category_id'] ) ) {
284 | 			$this->api_results->events = array_filter( $this->api_results->events, array( $this, 'filter_by_category' ) );
285 | 		}
286 | 
287 | 		// Filter by subcategory: 'subcategory_id'
288 | 		if ( isset( $this->query_vars['subcategory_id'] ) && is_integer( $this->query_vars['subcategory_id'] ) ) {
289 | 			$this->api_results->events = array_filter( $this->api_results->events, array( $this, 'filter_by_subcategory' ) );
290 | 		}
291 | 
292 | 		// Filter by format: 'format_id'
293 | 		if ( isset( $this->query_vars['format_id'] ) && is_integer( $this->query_vars['format_id'] ) ) {
294 | 			$this->api_results->events = array_filter( $this->api_results->events, array( $this, 'filter_by_format' ) );
295 | 		}
296 | 
297 | 		// Limit the number of results: 'limit'
298 | 		if ( isset( $this->query_vars['limit'] ) && is_integer( $this->query_vars['limit'] ) ) {
299 | 			$this->api_results->events = array_slice( $this->api_results->events, 0, absint( $this->query_vars['limit'] ) );
300 | 		}
301 | 	}
302 | 
303 | 	/**
304 | 	 * Determine by ID if an event is to be filtered out.
305 | 	 *
306 | 	 * @access protected
307 | 	 *
308 | 	 * @param  object $event A single event from the API call results.
309 | 	 * @return bool True with no ID match, false if the ID is in the array of events to be removed.
310 | 	 */
311 | 	protected function filter_by_post_not_in( $event ) {
312 | 		// Allow events not found in the array.
313 | 		return ! in_array( $event->ID, $this->query_vars['post__not_in'] );
314 | 	}
315 | 
316 | 	/**
317 | 	 * Determine if an event is managed by a certain organizer.
318 | 	 *
319 | 	 * @access protected
320 | 	 *
321 | 	 * @param  object $event A single event from the API call results.
322 | 	 * @return bool True if properties match, false otherwise.
323 | 	 */
324 | 	protected function filter_by_organizer( $event ) {
325 | 		return ( isset( $event->organizer->id ) ) ? $event->organizer->id == $this->query_vars['organizer_id'] : false;
326 | 	}
327 | 
328 | 	/**
329 | 	 * Determine if an event is occurring at a given venue.
330 | 	 *
331 | 	 * @access protected
332 | 	 *
333 | 	 * @param  object $event A single event from the API call results.
334 | 	 * @return bool True if properties match, false otherwise.
335 | 	 */
336 | 	protected function filter_by_venue( $event ) {
337 | 		return ( isset( $event->venue->id ) ) ? $event->venue->id == $this->query_vars['venue_id'] : false;
338 | 	}
339 | 
340 | 	/**
341 | 	 * Determine if an event is part of a given category.
342 | 	 *
343 | 	 * @access protected
344 | 	 *
345 | 	 * @param  object $event A single event from the API call results.
346 | 	 * @return bool True if properties match, false otherwise.
347 | 	 */
348 | 	protected function filter_by_category( $event ) {
349 | 		return ( isset( $event->category->id ) ) ? $event->category->id == $this->query_vars['category_id'] : false;
350 | 	}
351 | 
352 | 	/**
353 | 	 * Determine if an event is part of a given subcategory.
354 | 	 *
355 | 	 * @access protected
356 | 	 *
357 | 	 * @param  object $event A single event from the API call results.
358 | 	 * @return bool True if properties match, false otherwise.
359 | 	 */
360 | 	protected function filter_by_subcategory( $event ) {
361 | 		return ( isset( $event->subcategory->id ) ) ? $event->subcategory->id == $this->query_vars['subcategory_id'] : false;
362 | 	}
363 | 
364 | 	/**
365 | 	 * Determine if an event is part of a given format.
366 | 	 *
367 | 	 * @access protected
368 | 	 *
369 | 	 * @param  object $event A single event from the API call results.
370 | 	 * @return bool True if properties match, false otherwise.
371 | 	 */
372 | 	protected function filter_by_format( $event ) {
373 | 		return ( isset( $event->format->id ) ) ? $event->format->id == $this->query_vars['format_id'] : false;
374 | 	}
375 | 
376 | 	/**
377 | 	 * Filter the permalink for events to point to our rewrites. // kwight: what about different permalink formats?
378 | 	 *
379 | 	 * @access public
380 | 	 *
381 | 	 * @param  string $url The original unfiltered permalink.
382 | 	 * @return string Permalink URL
383 | 	 */
384 | 	public function filter_event_permalink( $url ) { // eg. http://mysite.com/events/july-test-drive-11829569561
385 | 		if ( eventbrite_is_event() ) {
386 | 			$url = sprintf( '%1$s/%2$s/%3$s-%4$s/',
387 | 				esc_url( home_url() ),                             // protocol://domain
388 | 				sanitize_title( get_queried_object()->post_name ), // page-with-eventbrite-template
389 | 				sanitize_title( get_post()->post_title ),               // event-title
390 | 				absint( get_post()->ID )                                // event ID
391 | 			);
392 | 		}
393 | 
394 | 		return $url;
395 | 	}
396 | 
397 | 	/**
398 | 	 * Filter post metadata so that has_post_thumbnail() returns true for events with a logo URL.
399 | 	 *
400 | 	 * @access public
401 | 	 *
402 | 	 * @param  null    $check The filter's default value.
403 | 	 * @param  integer $object_id Event ID.
404 | 	 * @param  string  $meta_key Name of meta key being checked.
405 | 	 * @return string URL of event logo passed from the API.
406 | 	 */
407 | 	public function filter_post_metadata( $check, $object_id, $meta_key ) {
408 | 		// If we aren't dealing with an Eventbrite event or wanting the thumbnail ID, then it's business as usual.
409 | 		if ( ! eventbrite_is_event() || '_thumbnail_id' !== $meta_key ) {
410 | 			return null;
411 | 		}
412 | 
413 | 		// Get the event in question.
414 | 		$event = Eventbrite_Event::get_instance( $object_id );
415 | 
416 | 		// Return whatever we have for the logo URL, which is used for event Featured Images.
417 | 		return $event->logo_url;
418 | 	}
419 | 
420 | 	/**
421 | 	 * Replace featured images with the Eventbrite event logo.
422 | 	 *
423 | 	 * @access public
424 | 	 *
425 | 	 * @param  string $html Original unfiltered HTML for a featured image.
426 | 	 * @param  int $post_id The current event ID.
427 | 	 * @return string HTML <img> tag for the Eventbrite logo linked to the event single view.
428 | 	 */
429 | 	public function filter_event_logo( $html, $post_id ) {
430 | 		// Are we dealing with an Eventbrite event?
431 | 		if ( eventbrite_is_event() ) {
432 | 			$html = '';
433 | 
434 | 			// Get our event.
435 | 			$event = Eventbrite_Event::get_instance( $post_id );
436 | 
437 | 			// Does the event have a logo set?
438 | 			if ( ! empty( $event->logo_url ) ) {
439 | 				// No need for a permalink on event single views.
440 | 				if ( eventbrite_is_single() ) {
441 | 					$html = '<img src="' . esc_url( $event->logo_url ) . '" class="wp-post-image">';
442 | 				}
443 | 
444 | 				// Add a permalink to events on the listings template.
445 | 				else {
446 | 					$html = sprintf( '<a class="post-thumbnail" href="%1$s"><img src="%2$s" class="wp-post-image"></a>',
447 | 						esc_url( get_the_permalink() ),
448 | 						esc_url( $event->logo_url )
449 | 					);
450 | 				}
451 | 			}
452 | 		}
453 | 
454 | 		return $html;
455 | 	}
456 | 
457 | 	/**
458 | 	 * Adjust classes for Event <article>s.
459 | 	 *
460 | 	 * @access public
461 | 	 *
462 | 	 * @param  array $classes Unfiltered post classes
463 | 	 * @return array Filtered post classes
464 | 	 */
465 | 	public function filter_post_classes( $classes ) {
466 | 		if ( eventbrite_is_event() ) {
467 | 			$classes[] = 'eventbrite-event';
468 | 
469 | 			if ( ! empty( get_post()->logo_url ) ) {
470 | 				$classes[] = 'has-post-thumbnail';
471 | 			}
472 | 		}
473 | 
474 | 		return $classes;
475 | 	}
476 | 
477 | 	/**
478 | 	 * Change the author archive URL to that of the organizer.
479 | 	 *
480 | 	 * @access public
481 | 	 *
482 | 	 * @param  string $url Author archive URL, based on the current page or post.
483 | 	 * @return string Organizer name
484 | 	 */
485 | 	public function filter_author_url( $url ) {
486 | 		// See if we're working with an Eventbrite event.
487 | 		if ( eventbrite_is_event() ) {
488 | 			// Get the current page the link was clicked on.
489 | 			$url = get_permalink( get_queried_object_id() );
490 | 
491 | 			// If the event has an organizer set, append it to the URL. http://(page permalink)/organizer/(organizer name)-(organizer ID)/
492 | 			if ( ! empty( eventbrite_event_organizer()->name ) ) {
493 | 				$url .= 'organizer/' . sanitize_title( eventbrite_event_organizer()->name ) . '-' . absint( eventbrite_event_organizer()->id );
494 | 			}
495 | 		}
496 | 
497 | 		return trailingslashit( $url );
498 | 	}
499 | 
500 | 	/**
501 | 	 * Change the author name to that of the event's organizer.
502 | 	 *
503 | 	 * @access public
504 | 	 *
505 | 	 * @param  string $name Author name, based on the current page or post.
506 | 	 * @return string Organizer name
507 | 	 */
508 | 	public function filter_author_name( $name ) {
509 | 		if ( eventbrite_is_event() ) {
510 | 			if ( ! empty( eventbrite_event_organizer()->name ) ) {
511 | 				$name = eventbrite_event_organizer()->name;
512 | 			}
513 | 		}
514 | 
515 | 		return $name;
516 | 	}
517 | }
518 | 


--------------------------------------------------------------------------------
/inc/class-eventbrite-requirements.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Eventbrite Requirements class, which prompts to install and activate Keyring if it's not currently active.
  4 |  *
  5 |  * @package Eventbrite_API
  6 |  */
  7 | 
  8 | class Eventbrite_Requirements {
  9 | 	/**
 10 | 	 * Class instance.
 11 | 	 *
 12 | 	 * @var object
 13 | 	 */
 14 | 	public static $instance;
 15 | 
 16 | 	/**
 17 | 	 * The class constructor.
 18 | 	 *
 19 | 	 * @access public
 20 | 	 */
 21 | 	public function __construct() {
 22 | 		// Assign our instance.
 23 | 		self::$instance = $this;
 24 | 
 25 | 		// Add hooks.
 26 | 		add_action( 'admin_notices', array( $this, 'display_admin_notice' ) );
 27 | 		add_filter( 'keyring_eventbrite_request_token_params', array( $this, 'add_connection_referrer' ) );
 28 | 	}
 29 | 
 30 | 	/**
 31 | 	 * Check if we have a valid user connection to Eventbrite.
 32 | 	 *
 33 | 	 * @return bool True if a valid user token exists, false otherwise.
 34 | 	 */
 35 | 	public static function has_active_connection() {
 36 | 		// Definitely no connection if Keyring isn't activated.
 37 | 		if ( ! class_exists( 'Keyring_SingleStore' ) ) {
 38 | 			return false;
 39 | 		}
 40 | 
 41 | 		// Let's check for Eventbrite connections.
 42 | 		$tokens = Keyring_SingleStore::init()->get_tokens( array( 'service'=>'eventbrite', 'user_id' => 0 ) );
 43 | 		if ( ! empty( $tokens[0] ) ) {
 44 | 			return true;
 45 | 		} else {
 46 | 			return false;
 47 | 		}
 48 | 	}
 49 | 
 50 | 	/**
 51 | 	 * Display admin notices to help users solve requirements for getting events.
 52 | 	 *
 53 | 	 * @access public
 54 | 	 */
 55 | 	public function display_admin_notice() {
 56 | 		// Don't display notices to users that can't do anything about it.
 57 | 		if ( ! current_user_can( 'install_plugins' ) ) {
 58 | 			return;
 59 | 		}
 60 | 
 61 | 		// Notices are only displayed on the dashboard, plugins, tools, and settings admin pages.
 62 | 		$page = get_current_screen()->base;
 63 | 		$display_on_pages = array(
 64 | 			'dashboard',
 65 | 			'plugins',
 66 | 			'tools',
 67 | 			'options-general',
 68 | 		);
 69 | 		if ( ! in_array( $page, $display_on_pages ) ) {
 70 | 			return;
 71 | 		}
 72 | 
 73 | 		// We're all fired up. No need for any admin notices.
 74 | 		if ( self::has_active_connection() ) {
 75 | 			return;
 76 | 		}
 77 | 
 78 | 		// Keyring is not already installed.
 79 | 		if ( ! file_exists( plugin_dir_path( dirname( __DIR__ ) ) . 'keyring' ) ) {
 80 | 			$notice = sprintf( __( 'Eventbrite needs the <a href="%1$s">Keyring plugin</a> to work. <a href="%2$s" class="thickbox">Install Keyring</a>.', 'eventbrite-api' ),
 81 | 				'https://wordpress.org/plugins/keyring/',
 82 | 				esc_url( network_admin_url( 'plugin-install.php?tab=plugin-information&plugin=keyring&TB_iframe=true&width=600&height=550' ) )
 83 | 			);
 84 | 		}
 85 | 
 86 | 		// Keyring is installed, just not activated.
 87 | 		elseif ( ! is_plugin_active( 'keyring/keyring.php' ) ) {
 88 | 			$notice = sprintf( __( 'Eventbrite needs the <a href="%1$s">Keyring plugin</a> activated, with a connection to eventbrite.com. <a href="%2$s">Activate Keyring</a>.', 'eventbrite-api' ),
 89 | 				'https://wordpress.org/plugins/keyring/',
 90 | 				esc_url( wp_nonce_url( network_admin_url( 'plugins.php?action=activate&plugin=keyring/keyring.php&plugin_status=all&paged=1&s' ), 'activate-plugin_keyring/keyring.php' ) )
 91 | 			);
 92 | 		}
 93 | 
 94 | 		// We don't have an active Keyring connection to Eventbrite.
 95 | 		elseif ( ! self::has_active_connection() ) {
 96 | 			$notice = sprintf( __( 'The Eventbrite API plugin needs a working connection to eventbrite.com. We recommend first <a href="%1$s">logging in</a> to your eventbrite.com account. <a href="%2$s">Connect to Eventbrite</a>.', 'eventbrite-api' ),
 97 | 				'https://www.eventbrite.com/login/',
 98 | 				esc_url( get_admin_url( null, 'tools.php?page=keyring&action=services' ) )
 99 | 			);
100 | 		}
101 | 
102 | 		// Output notice HTML.
103 | 		printf( '<div id="message" class="updated"><p>%s</p></div>', $notice );
104 | 	}
105 | 
106 | 	/**
107 | 	 * Append a referrer to the OAuth request made to Eventbrite, giving them an idea of WordPress adoption.
108 | 	 *
109 | 	 * @param array $params Parameters to be passed on an OAuth request.
110 | 	 * @return array OAuth request parameters with the referral added.
111 | 	 */
112 | 	public function add_connection_referrer( $params ) {
113 | 		if ( ! isset( $params['ref'] ) ) {
114 | 			$params['ref'] = 'wpoauth';
115 | 		}
116 | 
117 | 		return $params;
118 | 	}
119 | }
120 | 
121 | new Eventbrite_Requirements;
122 | 


--------------------------------------------------------------------------------
/inc/class-eventbrite-templates.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Eventbrite_Templates class, for handling Eventbrite template redirection, file includes, and rewrite rules.
  4 |  *
  5 |  * @package Eventbrite_API
  6 |  */
  7 | 
  8 |  class Eventbrite_Templates {
  9 | 	/**
 10 | 	 * Our constructor.
 11 | 	 *
 12 | 	 * @access public
 13 | 	 */
 14 | 	public function __construct() {
 15 |  		// Register hooks.
 16 | 		add_filter( 'query_vars', array( $this, 'add_query_vars' ) );
 17 | 		add_filter( 'rewrite_rules_array', array( $this, 'add_rewrite_rules' ) );
 18 | 		add_filter( 'theme_page_templates', array( $this, 'inject_page_template' ), 10, 3 );
 19 | 		add_action( 'template_include', array( $this, 'check_templates' ) );
 20 | 		add_action( 'wp_enqueue_scripts', array( $this, 'enqueue_styles' ) );
 21 | 		add_action( 'body_class', array( $this, 'adjust_body_classes' ) );
 22 | 		add_action( 'save_post_page', array( $this, 'flush_rewrite_rules_on_save_post' ), 10, 2 );
 23 | 		add_action( 'updated_postmeta', array( $this, 'flush_rewrite_rules_on_updated_postmeta' ), 10, 3 );
 24 |  	}
 25 | 
 26 | 	/**
 27 | 	 * Add Eventbrite-specific query vars so they are recognized by WP_Query.
 28 | 	 *
 29 | 	 * @access public
 30 | 	 *
 31 | 	 * @param array $query_vars Core default query vars.
 32 | 	 * @return array Query vars including our Eventbrite-specific vars.
 33 | 	 */
 34 | 	public function add_query_vars( $query_vars ) {
 35 | 		$query_vars = array_merge( $query_vars, array( 'eventbrite_id', 'organizer_id', 'venue_id' ) );
 36 | 
 37 | 		return $query_vars;
 38 | 	}
 39 | 
 40 | 	/**
 41 | 	 * Add rewrite rules for Eventbrite views.
 42 | 	 *
 43 | 	 * @access public
 44 | 	 *
 45 | 	 * @param  array $wp_rules WordPress rewrite rules.
 46 | 	 * @return array All rewrite rules (WordPress and Eventbrite rules combined).
 47 | 	 */
 48 | 	public function add_rewrite_rules( $wp_rules ) {
 49 | 		$eb_rules = array();
 50 | 
 51 | 		// Get all pages that are using the Eventbrite page template.
 52 | 		$pages = get_pages(array(
 53 | 			'meta_key' => '_wp_page_template',
 54 | 			'meta_value' => 'eventbrite-index.php',
 55 | 		));
 56 | 
 57 | 		// If any pages are using the template, add rewrite rules for each of them.
 58 | 		if ( $pages ) {
 59 | 			foreach ( $pages as $page ) {
 60 | 				// Add rules for "author" archives (meaning all events by an organizer).
 61 | 				$eb_rules_key = sprintf( '(%s)/organizer/[0-9a-z-]+-(\d+)/?$', $page->post_name );
 62 | 				$eb_rules[$eb_rules_key] = 'index.php?pagename=$matches[1]&organizer_id=$matches[2]';
 63 | 				$eb_rules_key = sprintf( '(%s)/organizer/[0-9a-z-]+-(\d+)/page/([0-9]{1,})/?$', $page->post_name );
 64 | 				$eb_rules[$eb_rules_key] = 'index.php?pagename=$matches[1]&organizer_id=$matches[2]&paged=$matches[3]';
 65 | 
 66 | 				// Add rules for venue archives (meaning all events at a given venue).
 67 | 				$eb_rules_key = sprintf( '(%s)/venue/[0-9a-z-]+-(\d+)/?$', $page->post_name );
 68 | 				$eb_rules[$eb_rules_key] = 'index.php?pagename=$matches[1]&venue_id=$matches[2]';
 69 | 				$eb_rules_key = sprintf( '(%s)/venue/[0-9a-z-]+-(\d+)/page/([0-9]{1,})/?$', $page->post_name );
 70 | 				$eb_rules[$eb_rules_key] = 'index.php?pagename=$matches[1]&venue_id=$matches[2]&paged=$matches[3]';
 71 | 
 72 | 				// Add a rule for event single views. Event IDs are 11 digits long (for the foreseeable future).
 73 | 				$eb_rules_key = sprintf( '(%s)/[0-9a-z-]+-(\d{10,11})/?$', $page->post_name );
 74 | 				$eb_rules[$eb_rules_key] = 'index.php?pagename=$matches[1]&eventbrite_id=$matches[2]';
 75 | 			}
 76 | 		}
 77 | 
 78 | 		// Combine all rules and return.
 79 | 		$rules = array_merge( $eb_rules + $wp_rules );
 80 | 		return $rules;
 81 | 	}
 82 | 
 83 | 	/**
 84 | 	 * Make the Eventbrite Events page template available to the templates dropdown.
 85 | 	 *
 86 | 	 * @access public
 87 | 	 *
 88 | 	 * @param  array $templates The theme's registered page templates.
 89 | 	 * @return array $templates Page templates with the Eventbrite index template added.
 90 | 	 */
 91 | 	public function inject_page_template( $templates ) {
 92 | 		$templates['eventbrite-index.php'] = __( 'Eventbrite Events', 'eventbrite-api' );
 93 | 		return $templates;
 94 | 	}
 95 | 
 96 | 	/**
 97 | 	 * Check if we need to use Eventbrite page templates, either from the theme or our plugin.
 98 | 	 *
 99 | 	 * @access public
100 | 	 *
101 | 	 * @param  string $template The template to be used according to the Template Hierarchy.
102 | 	 * @return string Template file name.
103 | 	 */
104 | 	public function check_templates( $template ) {
105 | 		// If we have an 'eventbrite_id' query var, we're dealing with an event single view.
106 | 		if ( get_query_var( 'eventbrite_id' ) ) {
107 | 			// A default theme is being used; we've got special templates for those.
108 | 			if ( $this->default_theme_activated() ) {
109 | 				$template = plugin_dir_path( __DIR__ ) . 'tmpl/compat/' . get_template() . '/eventbrite-single.php';
110 | 			}
111 | 
112 | 			// The theme declares support, look for an Eventbrite single template.
113 | 			elseif ( current_theme_supports( 'eventbrite' ) && file_exists( get_stylesheet_directory() . '/eventbrite/eventbrite-single.php' ) ) {
114 | 				$template = esc_url( get_stylesheet_directory() . '/eventbrite/eventbrite-single.php' );
115 | 			}
116 | 
117 | 			// Oh, maybe the theme is a child theme; let's check the parent theme for a template too.
118 | 			elseif ( current_theme_supports( 'eventbrite' ) && file_exists( get_template_directory() . '/eventbrite/eventbrite-single.php' ) ) {
119 | 				$template = esc_url( get_template_directory() . '/eventbrite/eventbrite-single.php' );
120 | 			}
121 | 
122 | 			// No template was found, and it's not a default theme, so use the one included with the plugin.
123 | 			else {
124 | 				$template = plugin_dir_path( __DIR__ ) . 'tmpl/eventbrite-single.php';
125 | 			}
126 | 		}
127 | 
128 | 		// Check if we have a page using the Eventbrite event listing template.
129 | 		elseif ( 'eventbrite-index.php' == get_post_meta( get_the_ID(), '_wp_page_template', true ) ) {
130 | 			// We're using a default theme. We've got special template files for those.
131 | 			if ( $this->default_theme_activated() ) {
132 | 				$template = plugin_dir_path( __DIR__ ) . 'tmpl/compat/' . get_template() . '/eventbrite-index.php';
133 | 			}
134 | 
135 | 			// The theme declares support, looks for an Eventbrite index template.
136 | 			elseif ( current_theme_supports( 'eventbrite' ) && file_exists( get_stylesheet_directory() . '/eventbrite/eventbrite-index.php' ) ) {
137 | 				$template = esc_url( get_stylesheet_directory() . '/eventbrite/eventbrite-index.php' );
138 | 			}
139 | 
140 | 			// Let a child theme inherit its parent's index template.
141 | 			elseif ( current_theme_supports( 'eventbrite' ) && file_exists( get_template_directory() . '/eventbrite/eventbrite-index.php' ) ) {
142 | 				$template = esc_url( get_template_directory() . '/eventbrite/eventbrite-index.php' );
143 | 			}
144 | 
145 | 			// Nothing in the theme, and it's not a default theme; just use our regular template.
146 | 			else {
147 | 				$template = plugin_dir_path( __DIR__ ) . 'tmpl/eventbrite-index.php';
148 | 			}
149 | 		}
150 | 
151 | 		return $template;
152 | 	}
153 | 
154 | 	/**
155 | 	 * Enqueue any styles required for default themes.
156 | 	 *
157 | 	 * @access public
158 | 	 */
159 | 	public function enqueue_styles() {
160 | 		// Bail if we're not using a default theme.
161 | 		if ( ! $this->default_theme_activated() ) {
162 | 			return;
163 | 		}
164 | 
165 | 		// If there's a stylesheet for this default theme, enqueue it.
166 | 		$style_rel_path = 'tmpl/compat/' . get_template() . '/eventbrite-style.css';
167 | 		if ( file_exists( plugin_dir_path( dirname( __FILE__ ) ) . $style_rel_path ) ) {
168 | 			wp_enqueue_style(
169 | 				'eventbrite-styles',
170 | 				plugins_url( $style_rel_path, dirname( __FILE__ ) )
171 | 			);
172 | 		}
173 | 	}
174 | 
175 | 	/**
176 | 	 * Adjust body classes when our Eventbrite templates are in use.
177 | 	 *
178 | 	 * @access public
179 | 	 *
180 | 	 * @param  array $classes Unfiltered body classes
181 | 	 * @return array Filtered body classes
182 | 	 */
183 | 	public function adjust_body_classes( $classes ) {
184 | 		// Check if we're loading an Eventbrite single view.
185 | 		if ( eventbrite_is_single() ) {
186 | 			$classes[] = 'single';
187 | 			$classes[] = 'single-event';
188 | 			$key = array_search( 'page', $classes );
189 | 			unset( $classes[ $key ] );
190 | 		}
191 | 
192 | 		// Check for an Eventbrite index view.
193 | 		elseif ( 'eventbrite-index.php' == get_post_meta( get_the_ID(), '_wp_page_template', true ) ) {
194 | 			$classes[] = 'archive';
195 | 			$classes[] = 'archive-eventbrite';
196 | 			foreach ( array( 'page', 'singular' ) as $value ) {
197 | 				$key = array_search( $value, $classes );
198 | 				unset( $classes[ $key ] );
199 | 			}
200 | 		}
201 | 
202 | 		return $classes;
203 | 	}
204 | 
205 | 	/**
206 | 	 * Check if a default theme is active.
207 | 	 *
208 | 	 * @access protected
209 | 	 *
210 | 	 * @return bool True if a default theme is active, false otherwise.
211 | 	 */
212 | 	protected function default_theme_activated() {
213 | 		// Our supported default themes.
214 | 		$default_themes = array(
215 | 			'twentyten',
216 | 			'twentyeleven',
217 | 			'twentytwelve',
218 | 			'twentythirteen',
219 | 			'twentyfourteen',
220 | 			'twentyfifteen',
221 | 		);
222 | 
223 | 		return in_array( get_template(), $default_themes );
224 | 	}
225 | 
226 | 	/**
227 | 	 * Flush rewrite rules when the Eventbrite Event page template is active on a saved page.
228 | 	 *
229 | 	 * @access public
230 | 	 *
231 | 	 * @param int $post_id Post ID
232 | 	 * @param object $post WP_Post object
233 | 	 */
234 | 	public function flush_rewrite_rules_on_save_post( $post_id, $post ) {
235 | 		if ( 'eventbrite-index.php' == $post->page_template ) {
236 | 			flush_rewrite_rules();
237 | 		}
238 | 	}
239 | 
240 | 	/**
241 | 	 * Flush rewrite rules when a page template change is registered.
242 | 	 *
243 | 	 * @access public
244 | 	 *
245 | 	 * @param int $meta_id ID of updated metadata entry
246 | 	 * @param int $object_id Object ID
247 | 	 * @param string $meta_key Meta key
248 | 	 */
249 | 	public function flush_rewrite_rules_on_updated_postmeta( $meta_id, $object_id, $meta_key ) {
250 | 		if ( '_wp_page_template' == $meta_key ) {
251 | 			flush_rewrite_rules();
252 | 		}
253 | 	}
254 |  }
255 | 
256 |  new Eventbrite_Templates();
257 | 


--------------------------------------------------------------------------------
/inc/functions.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | /**
  3 |  * Eventbrite functions.
  4 |  *
  5 |  * @package Eventbrite_API
  6 |  */
  7 | 
  8 | if ( ! function_exists( 'eventbrite_get_events' ) ) :
  9 | /**
 10 |  * Get an array of Eventbrite events, in the format expected by Eventbrite_Event
 11 |  *
 12 |  * @param  array $params Parameters for the user_owned_events endpoint to pass during the API call.
 13 |  * @param  bool $force Force an API call, don't use cache.
 14 |  * @return object API results
 15 |  */
 16 | function eventbrite_get_events( $params = array(), $force = false ) {
 17 | 	return eventbrite()->get_user_owned_events( $params, $force );
 18 | }
 19 | endif;
 20 | 
 21 | if ( ! function_exists( 'eventbrite_get_event' ) ) :
 22 | /**
 23 |  * Retrieves event data given an event ID.
 24 |  *
 25 |  * @param  int $id The Eventbrite event ID to be requested.
 26 |  * @param  bool $force Force an API call, don't use cache.
 27 |  * @return object Event
 28 |  */
 29 | function eventbrite_get_event( $id = false, $force = false ) {
 30 | 	// Bail if no ID is passed in.
 31 | 	if ( empty( $id ) ) {
 32 | 		return null;
 33 | 	}
 34 | 
 35 | 	// Retrieve and return our event.
 36 | 	return eventbrite()->get_event( $id, $force );
 37 | }
 38 | endif;
 39 | 
 40 | if ( ! function_exists( 'eventbrite_search' ) ) :
 41 | /**
 42 |  * Search Eventbrite public events by any user.
 43 |  * Note that not limiting the scope of the search somehow will likely result in timeout errors.
 44 |  *
 45 |  * @param  array $params Parameters for the event_search endpoint, to be passed during the API call.
 46 |  * @param  bool $force Force an API call, don't use cache.
 47 |  * @return object API results
 48 |  */
 49 | function eventbrite_search( $params = array(), $force = false ) {
 50 | 	return eventbrite()->do_event_search( $params, $force );
 51 | }
 52 | endif;
 53 | 
 54 | if ( ! function_exists( 'eventbrite_is_event' ) ) :
 55 | /**
 56 |  * Determine if a given object, given ID, or the current post is an Eventbrite event.
 57 |  *
 58 |  * @param  mixed $post The current post object or event ID needed by Eventbrite_Event.
 59 |  * @return bool True if it's an Eventbrite event, false otherwise.
 60 |  */
 61 | function eventbrite_is_event( $post = null ) {
 62 | 	// If no post is given, assume the current post.
 63 | 	if ( ! $post ) {
 64 | 		global $post;
 65 | 	}
 66 | 
 67 | 	// Check if the post is an Eventbrite_Event object.
 68 | 	if ( is_a( $post, 'Eventbrite_Event' ) ) {
 69 | 		return true;
 70 | 	}
 71 | 
 72 | 	// Maybe we're working with an event ID.
 73 | 	if ( is_integer( $post ) && 10 < strlen( strval( $id ) ) ) {
 74 | 		$event = eventbrite_get_event( absint( $post ) );
 75 | 		return ( empty( $event->error ) );
 76 | 	}
 77 | 
 78 | 	// No dice.
 79 | 	return false;
 80 | }
 81 | endif;
 82 | 
 83 | if ( ! function_exists( 'eventbrite_paging_nav' ) ) :
 84 | /**
 85 |  * Paging navigation on event listings, using paginate_links().
 86 |  *
 87 |  * @param object $events The current Eventbrite_Query object requiring paging navigation.
 88 |  */
 89 | function eventbrite_paging_nav( $events = null ) {
 90 | 	// Bail if we don't have a valid Eventbrite_Query object.
 91 | 	if ( ! is_a( $events, 'Eventbrite_Query' ) ) {
 92 | 		return;
 93 | 	}
 94 | 
 95 | 	// Bail if we only have one page and don't need pagination.
 96 | 	if ( $events->max_num_pages < 2 ) {
 97 | 		return;
 98 | 	}
 99 | 
100 | 	// Set arguments for paginate_links().
101 | 	$args = array(
102 | 		'current'   => get_query_var( 'paged' ) ? intval( get_query_var( 'paged' ) ) : 1,
103 | 		'next_text' => __( 'Next &rarr;', 'eventbrite' ),
104 | 		'prev_text' => __( '&larr; Previous', 'eventbrite' ),
105 | 		'total'     => $events->max_num_pages,
106 | 	);
107 | 
108 | 	// If we have 10 or less pages, just show them all.
109 | 	if ( 10 >= $events->max_num_pages ) {
110 | 		$args['show_all'] = true;
111 | 	}
112 | 
113 | 	// Output our markup. ?>
114 | 	<nav class="navigation paging-navigation pagination" role="navigation">
115 | 		<h1 class="screen-reader-text"><?php esc_html_e( 'Events navigation', 'eventbrite' ); ?></h1>
116 | 		<div class="nav-links">
117 | 			<?php echo paginate_links( apply_filters( 'eventbrite_paginate_links_args', $args, $events ) ); ?>
118 | 		</div><!-- .pagination -->
119 | 	</nav><!-- .navigation -->
120 | <?php }
121 | endif;
122 | 
123 | if ( ! function_exists( 'eventbrite_is_single' ) ) :
124 | /**
125 |  * Determine if a query is for an event single view.
126 |  *
127 |  * @param  mixed $query Null, or an Eventbrite_Query object.
128 |  * @return bool True if an event single view, false otherwise.
129 |  */
130 | function eventbrite_is_single( $query = null ) {
131 | 	// If an Eventbrite_Query object is passed in, check the is_single property.
132 | 	if ( is_a( $query, 'Eventbrite_Query' ) ) {
133 | 		return $query->is_single;
134 | 	}
135 | 
136 | 	// If the eventbrite_id query var has something, then it's an event single view.
137 | 	elseif ( get_query_var( 'eventbrite_id' ) ) {
138 | 		return true;
139 | 	}
140 | 
141 | 	// Whatever it is, if anything, it's not an event single view.
142 | 	else {
143 | 		return false;
144 | 	}
145 | }
146 | endif;
147 | 
148 | if ( ! function_exists( 'eventbrite_event_meta' ) ) :
149 | /**
150 |  * Output event information such as date, time, venue, and organizer
151 |  */
152 | function eventbrite_event_meta() {
153 | 	// Determine our separator.
154 | 	$separator = apply_filters( 'eventbrite_meta_separator', '<span class="sep"> &middot; </span>' );
155 | 
156 | 	// Start our HTML output with the event time.
157 | 	$time = '<span class="event-time">' . eventbrite_event_time() . '</span>';
158 | 
159 | 	// Add a venue name if available.
160 | 	$venue = '';
161 | 	if ( ! empty( eventbrite_event_venue()->name ) ) {
162 | 		$venue = sprintf( '%s<span class="event-venue"><a class="event-venue-link url fn n" href="%s"><span class="event-venue-text">%s</span></a></span>',
163 | 			wp_kses( $separator, array(
164 | 				'span' => array(
165 | 					'class' => array(),
166 | 				),
167 | 			) ),
168 | 			esc_url( eventbrite_venue_get_archive_link() ),
169 | 			esc_html( eventbrite_event_venue()->name )
170 | 		);
171 | 	}
172 | 
173 | 	// Add the organizer's name if available. Author-related functions are filtered to use the event's organizer.
174 | 	$organizer = '';
175 | 	if ( ! empty( eventbrite_event_organizer()->name ) ) {
176 | 		$organizer = sprintf( '%s<span class="event-organizer"><a class="event-organizer-link url fn n" href="%s"><span class="event-organizer-text">%s</span></a></span>',
177 | 			wp_kses( $separator, array(
178 | 				'span' => array(
179 | 					'class' => array(),
180 | 				),
181 | 			) ),
182 | 			esc_url( get_author_posts_url( get_the_author_meta( 'ID' ) ) ),
183 | 			esc_html( get_the_author() )
184 | 		);
185 | 	}
186 | 
187 | 	// Add a contextual link to event details.
188 | 	if ( eventbrite_is_single() ) {
189 | 		// Link to event info on eventbrite.com.
190 | 		$url = add_query_arg( array( 'ref' => 'wporglink' ), eventbrite_event_eb_url() );
191 | 	} else {
192 | 		// Link to the event single view.
193 | 		$url = get_the_permalink();
194 | 	}
195 | 
196 | 	$details = sprintf( '%s<span class="event-details"><a class="event-details-link" href="%s"><span class="event-details-text">%s</span></a></span>',
197 | 		wp_kses( $separator, array(
198 | 			'span' => array(
199 | 				'class' => array(),
200 | 			),
201 | 		) ),
202 | 		esc_url( $url ),
203 | 		esc_html__( 'Details', 'eventbrite_api' )
204 | 	);
205 | 
206 | 	// Assemble our HTML. Yugly.
207 | 	$html = sprintf( _x( '%1$s%2$s%3$s%4$s', '%1$s: time, %2$s: venue, %3$s: organizer, %4$s: event details (only on index views)', 'eventbrite-api' ),
208 | 		$time,
209 | 		$venue,
210 | 		$organizer,
211 | 		$details
212 | 	);
213 | 
214 | 	echo apply_filters( 'eventbrite_event_meta', $html, $time, $venue, $organizer, $details );
215 | }
216 | endif;
217 | 
218 | if ( ! function_exists( 'eventbrite_event_time' ) ) :
219 | /**
220 |  * Return an event's time.
221 |  *
222 |  * @return string Event time.
223 |  */
224 | function eventbrite_event_time() {
225 | 	// Collect our formats from the admin.
226 | 	$date_format = get_option( 'date_format' );
227 | 	$time_format = get_option( 'time_format' );
228 | 	$combined_format = apply_filters( 'eventbrite_date_time_format', $date_format . ', ' . $time_format, $date_format, $time_format );
229 | 
230 | 	// Determine if the end time needs the date included (in the case of multi-day events).
231 | 	$end_time = ( eventbrite_is_multiday_event() )
232 | 		? mysql2date( $combined_format, eventbrite_event_end()->local )
233 | 		: mysql2date( $time_format, eventbrite_event_end()->local );
234 | 
235 | 	// Assemble the full event time string.
236 | 	$event_time = sprintf(
237 | 		_x( '%1$s - %2$s', 'Event date and time. %1$s = start time, %2$s = end time', 'eventbrite_api' ),
238 | 		esc_html( mysql2date( $combined_format, eventbrite_event_start()->local ) ),
239 | 		esc_html( $end_time )
240 | 	);
241 | 
242 | 	return $event_time;
243 | }
244 | endif;
245 | 
246 | if ( ! function_exists( 'eventbrite_is_multiday_event' ) ) :
247 | /**
248 |  * Determine if an event spans multiple calendar days.
249 |  *
250 |  * @return bool True if start and end date are the same, false otherwise.
251 |  */
252 | function eventbrite_is_multiday_event() {
253 | 	// Set date variables for comparison.
254 | 	$start_date = mysql2date( 'Ymd', eventbrite_event_start()->local );
255 | 	$end_date = mysql2date( 'Ymd', eventbrite_event_end()->local );
256 | 
257 | 	// Return true if they're different, false otherwise.
258 | 	return ( $start_date !== $end_date );
259 | }
260 | endif;
261 | 
262 | if ( ! function_exists( 'eventbrite_event_eb_url' ) ) :
263 | /**
264 |  * Give the URL to an event's public viewing page on eventbrite.com.
265 |  *
266 |  * @return string URL on eventbrite.com
267 |  */
268 | function eventbrite_event_eb_url() {
269 | 	return apply_filters( 'eventbrite_event_eb_url', get_post()->url );
270 | }
271 | endif;
272 | 
273 | if ( ! function_exists( 'eventbrite_event_venue' ) ) :
274 | /**
275 |  * Give access to the current event's venue properties: address, resource_uri, id, name, latitude, longitude
276 |  *
277 |  * @return object Venue info
278 |  */
279 | function eventbrite_event_venue() {
280 | 	return apply_filters( 'eventbrite_event_venue', get_post()->venue );
281 | }
282 | endif;
283 | 
284 | if ( ! function_exists( 'eventbrite_event_organizer' ) ) :
285 | /**
286 |  * Give access to the current event's organizer properties: description, logo, resource_uri, id, name, url, num_past_events, num_future_events
287 |  *
288 |  * @return object Organizer info
289 |  */
290 | function eventbrite_event_organizer() {
291 | 	return apply_filters( 'eventbrite_event_organizer', get_post()->organizer );
292 | }
293 | endif;
294 | 
295 | if ( ! function_exists( 'eventbrite_event_category' ) ) :
296 | /**
297 |  * Give access to the current event's category properties: resource_uri, id, name, name_localized, short_name, short_name_localized
298 |  *
299 |  * @return object Category info
300 |  */
301 | function eventbrite_event_category() {
302 | 	return apply_filters( 'eventbrite_event_category', get_post()->category );
303 | }
304 | endif;
305 | 
306 | if ( ! function_exists( 'eventbrite_event_subcategory' ) ) :
307 | /**
308 |  * Give access to the current event's subcategory properties: resource_uri, id, name, name_localized, short_name, short_name_localized
309 |  *
310 |  * @return object Subcategory info
311 |  */
312 | function eventbrite_event_subcategory() {
313 | 	return apply_filters( 'eventbrite_event_subcategory', get_post()->subcategory );
314 | }
315 | endif;
316 | 
317 | if ( ! function_exists( 'eventbrite_event_format' ) ) :
318 | /**
319 |  * Give access to the current event's format properties: resource_uri, id, name, name_localized, short_name, short_name_localized
320 |  *
321 |  * @return object Format info
322 |  */
323 | function eventbrite_event_format() {
324 | 	return apply_filters( 'eventbrite_event_format', get_post()->format );
325 | }
326 | endif;
327 | 
328 | if ( ! function_exists( 'eventbrite_event_start' ) ) :
329 | /**
330 |  * Give access to the current event's start time: timezone, local, utc
331 |  *
332 |  * @return object Start time properties
333 |  */
334 | function eventbrite_event_start() {
335 | 	return apply_filters( 'eventbrite_event_start', get_post()->start );
336 | }
337 | endif;
338 | 
339 | if ( ! function_exists( 'eventbrite_event_end' ) ) :
340 | /**
341 |  * Give access to the current event's end time: timezone, local, utc
342 |  *
343 |  * @return object End time properties
344 |  */
345 | function eventbrite_event_end() {
346 | 	return apply_filters( 'eventbrite_event_end', get_post()->end );
347 | }
348 | endif;
349 | 
350 | if ( ! function_exists( 'eventbrite_venue_get_archive_link' ) ) :
351 | /**
352 |  * Output a permalink to a venue's "archive" page.
353 |  *
354 |  * @return string URL
355 |  */
356 | function eventbrite_venue_get_archive_link() {
357 | 	// Get the permalink of the current template page.
358 | 	$url = get_permalink( get_queried_object_id() );
359 | 
360 | 	// If the event has a venue set, append it to the URL. http://(page permalink)/venue/(venue name)-(venue ID)/
361 | 	if ( ! empty( eventbrite_event_venue()->name ) ) {
362 | 		$url .= 'venue/' . sanitize_title( eventbrite_event_venue()->name ) . '-' . absint( eventbrite_event_venue()->id );
363 | 	}
364 | 
365 | 	return $url;
366 | }
367 | endif;
368 | 
369 | if ( ! function_exists( 'eventbrite_edit_post_link' ) ) :
370 | /**
371 |  * Output a link to edit the current event on eventbrite.com.
372 |  *
373 |  * @param string $text Anchor text.
374 |  * @param string $before Display before edit link.
375 |  * @param string $after Display after edit link.
376 |  */
377 | function eventbrite_edit_post_link( $text = null, $before = '', $after = '' ) {
378 | 	// Ensure the Edit link only shows to those that can edit posts.
379 | 	if ( ! current_user_can( 'install_plugins' ) ) {
380 | 		return;
381 | 	}
382 | 
383 | 	// Assemble the edit URL.
384 | 	$url = add_query_arg( array(
385 | 			'eid' => get_the_ID(),
386 | 			'ref' => 'wporgedit',
387 | 		), 'https://eventbrite.com/edit' );
388 | 
389 | 	// Output the formatted link.
390 | 	printf( '%s<a href="%s">%s</a>%s',
391 | 		$before,
392 | 		esc_url( $url ),
393 | 		esc_html( $text ),
394 | 		$after
395 | 	);
396 | }
397 | endif;
398 | 
399 | if ( ! function_exists( 'eventbrite_ticket_form_widget' ) ) :
400 | /**
401 |  * Insert the Eventbrite ticket form widget.
402 |  */
403 | function eventbrite_ticket_form_widget() {
404 | 	// Build the src attribute URL.
405 | 	$src = add_query_arg( array(
406 | 			'eid' => get_the_ID(),
407 | 			'ref' => 'etckt',
408 | 	), '//eventbrite.com/tickets-external' );
409 | 
410 | 	// Assemble our ticket info HTML.
411 | 	$ticket_html = sprintf( '<div class="eventbrite-widget"><iframe src="%1$s" height="%2$s" width="100%%" frameborder="0" vspace="0" hspace="0" marginheight="5" marginwidth="5" scrolling="auto" allowtransparency="true"></iframe></div>',
412 | 		esc_url( $src ),
413 | 		esc_attr( eventbrite_get_ticket_form_widget_height() )
414 | 	);
415 | 
416 | 	// Output the markup.
417 | 	echo apply_filters( 'eventbrite_ticket_form_widget', $ticket_html, $src );
418 | }
419 | endif;
420 | 
421 | if ( ! function_exists( 'eventbrite_get_ticket_form_widget_height' ) ) :
422 | /**
423 |  * Calculate the height of the ticket form widget iframe. Not perfect, but avoids having to do it with JS.
424 |  *
425 |  * @return  int Height of iframe
426 |  */
427 | function eventbrite_get_ticket_form_widget_height() {
428 | 	$sales_open = false;
429 | 
430 | 	// Set the starting height: includes the header (50), dates/sales (39+23), and call-to-action (75).
431 | 	$height = 190;
432 | 
433 | 	// Get tickets for the current event.
434 | 	$tickets = get_post()->tickets;
435 | 
436 | 	if ( is_array( $tickets ) ) {
437 | 		$tickets_height = 0;
438 | 		$sales_end = array();
439 | 
440 | 		foreach ( $tickets as $ticket ) {
441 | 			// Add height for each ticket type.
442 | 			$tickets_height += 85;
443 | 			// Note if any ticket types are still available.
444 | 			if ( 'AVAILABLE' === $ticket->on_sale_status ) {
445 | 				$sales_open = true;
446 | 				$sales_end[] = $ticket->sales_end;
447 | 			}
448 | 		}
449 | 
450 | 		// Adjust for no active ticket sales.
451 | 		if ( ! $sales_open ) {
452 | 			// Remove Sales End date.
453 | 			$height -= 22;
454 | 			// Add Sales Ended graphic.
455 | 			$height += 190;
456 | 			// Remove call-to-action section.
457 | 			$height -= 75;
458 | 		} else {
459 | 			// At least one ticket type is available, so add the ticket heights (accounting for same sales end times or not).
460 | 			$sales_end = array_unique( $sales_end );
461 | 			if ( 2 <= count( $sales_end ) ) {
462 | 				$tickets_height += count( $tickets ) * 18;
463 | 				$height -= 23;
464 | 			}
465 | 			$height += $tickets_height;
466 | 		}
467 | 	} else {
468 | 		// No ticket info to go by, we'll return a safe assumption of two ticket types with the same sales end time.
469 | 		$height += ( 2 * 85 );
470 | 	}
471 | 
472 | 	return (int) apply_filters( 'eventbrite_ticket_form_widget_height', $height );
473 | }
474 | endif;
475 | 
476 | /**
477 |  * Check if everything we need is working: Keyring is installed, activated, and has a valid user connection to Eventbrite.
478 |  *
479 |  * @return bool True if a valid user token exists, false otherwise.
480 |  */
481 | function eventbrite_has_active_connection() {
482 | 	return ( Eventbrite_Requirements::has_active_connection() );
483 | }
484 | 


--------------------------------------------------------------------------------
/readme.txt:
--------------------------------------------------------------------------------
  1 | === Eventbrite API ===
  2 | Contributors: jkudish, kwight
  3 | Tags: eventbrite, events, api, WordPress.com
  4 | Requires at least: 4.4
  5 | Tested up to: 4.9.5
  6 | Stable tag: 1.0.12
  7 | License: GPLv2 or later
  8 | License URI: http://www.gnu.org/licenses/gpl-2.0.html
  9 | 
 10 | Display Eventbrite events right in your WordPress site. Developers get easy-to-use tools for creating powerful, in-depth Eventbrite integrations.
 11 | 
 12 | == Description ==
 13 | 
 14 | The Eventbrite API plugin brings the power of Eventbrite to WordPress, for both users and developers. [Docs available here](http://automattic.github.io/eventbrite-api/).
 15 | 
 16 | By connecting to your [Eventbrite account](http://eventbrite.com/), events can be displayed directly on your WordPress.org website, complete with event details and ticket information. Events will blend in with the design of any theme, and events can be filtered by organizer or venue, just like post archives.
 17 | 
 18 | As a theme or plugin developer, you get simple-to-use tools for making any theme or plugin Eventbrite-compatible. Use the helper functions to remove the complexity and heavy-lifting of API calls, and take advantage of assorted template tags for displaying various event information.
 19 | 
 20 | *Eventbrite logo used by permission. Banner photo by [Daniel Robert Dinu](http://www.concertphotography.ro/), licensed under [CC0](http://creativecommons.org/choose/zero/).*
 21 | 
 22 | == Installation ==
 23 | 
 24 | The Eventbrite API plugin also requires the [Keyring plugin](https://wordpress.org/plugins/keyring/), which is used for managing the user's connection to eventbrite.com. Keyring needs to be installed, activated, and using a connection to eventbrite.com for any events to display on the website.
 25 | 
 26 | If the eventbrite API plugin is installed but missing Keyring or an eventbrite.com connection, admin notices will prompt the user with helpful links.
 27 | 
 28 | 1. Upload `eventbrite-api.zip` or search for it from the Plugins > Add New admin page.
 29 | 2. Activate the plugin through the Plugins menu.
 30 | 3. Repeat these steps for the [Keyring plugin](https://wordpress.org/plugins/keyring/).
 31 | 4. Log in to your Eventbrite account, create an app, and authorize Keyring.
 32 | 5. [Assign](http://codex.wordpress.org/Page_Templates#Selecting_a_Page_Template) the Eventbrite Events page template to a page. This will be the page that shows your Eventbrite events.
 33 | 
 34 | For more detailed instructions, see the Eventbrite API [user assistance page](http://automattic.github.io/eventbrite-api/users.html).
 35 | 
 36 | == Frequently Asked Questions ==
 37 | 
 38 | = Are there more detailed instructions for Keyring and getting connected to Eventbrite? =
 39 | 
 40 | Yes! Check out the [user assistance page](http://automattic.github.io/eventbrite-api/users.html) on the [Eventbrite API website](http://automattic.github.io/eventbrite-api/), and [post to the forums](https://wordpress.org/support/plugin/eventbrite-api/) if you need any further help.
 41 | 
 42 | = Events don't quite look like the rest of the theme – how can I fix it? =
 43 | 
 44 | While a theme doesn't need to know about the plugin to display events, it's always best if the theme developer optimizes their theme for Eventbrite. You can post on the [theme's forum](https://wordpress.org/support/) and send them [this link](https://github.com/Automattic/eventbrite-api). You can also send an email to themes@wordpress.com and we'll see what we can do to help. The following themes have already been optimized:
 45 | 
 46 | * Twenty Fifteen
 47 | * Twenty Fourteen
 48 | * Twenty Thirteen
 49 | * Twenty Twelve
 50 | * Twenty Eleven
 51 | * Twenty Ten
 52 | * [Bosco](https://wordpress.org/themes/bosco/)
 53 | * [Chunk](https://wordpress.org/themes/chunk/)
 54 | * [Coraline](https://wordpress.org/themes/coraline/)
 55 | * [Edin](https://wordpress.org/themes/edin/)
 56 | * [Fictive](https://wordpress.org/themes/fictive/)
 57 | * [Goran](https://wordpress.org/themes/goran/)
 58 | * [Ryu](https://wordpress.org/themes/ryu/)
 59 | * [Sketch](https://wordpress.org/themes/sketch/)
 60 | * [Sidekick](https://wordpress.org/themes/sidekick/)
 61 | * [Singl](https://wordpress.org/themes/singl/)
 62 | * [Superhero](https://wordpress.org/themes/superhero/)
 63 | * [Sorbet](https://wordpress.org/themes/sorbet/)
 64 | * [Tonal](https://wordpress.org/themes/tonal/)
 65 | * [Writr](https://wordpress.org/themes/writr/)
 66 | 
 67 | = I'm a theme developer; how can I make my theme Eventbrite-optimized? =
 68 | 
 69 | Assuming your theme is based on [Underscores](http://underscores.me/), most of the work is already done for you. Just load the theme, and compare your markup to that of the plugin's [included templates](https://github.com/Automattic/eventbrite-api/tree/master/tmpl). Make your own copies, adjusting the markup as needed, and then assign your templates in an `add_theme_support` call. Most themes can be done in under ten minutes. More details can be found at the [Eventbrite API GitHub repo](https://github.com/Automattic/eventbrite-api/).
 70 | 
 71 | = What Eventbrite endpoints are supported? =
 72 | 
 73 | The following endpoints are currently supported, with more on the way. Open an issue on GitHub to request support for others.
 74 | 
 75 | * `user_owned_events`: [Eventbrite documentation](http://developer.eventbrite.com/docs/user-owned-events/).
 76 | * `event_details`: [Eventbrite documentation](http://developer.eventbrite.com/docs/event-details/).
 77 | * `event_search`: [Eventbrite documentation](http://developer.eventbrite.com/docs/event-search/).
 78 | 
 79 | = Where can I get detailed documentation for working with the plugin? =
 80 | 
 81 | All development for Eventbrite API plugin is done through the [GitHub repo](https://github.com/Automattic/eventbrite-api/), and detailed documentation can be found on the repo's [GitHub page](http://automattic.github.io/eventbrite-api/developers.html).
 82 | 
 83 | = Who made this plugin? =
 84 | 
 85 | This plugin was developed by [Automattic](http://automattic.com/), in direct partnership with [Eventbrite](http://eventbrite.com). The Eventbrite name and logo are used by permission.
 86 | 
 87 | = Known issues =
 88 | 
 89 | The Eventbrite page template needs to be a parent page; it will not function properly as a subpage, giving 404 errors.
 90 | 
 91 | Caching for the Eventbrite API and the plugin itself will cause events to take up to ten minutes to show on the Eventbrite page. Disconnecting and reconnecting can force the events to refresh more quickly. For more detailed instructions, see the Eventbrite API [user assistance page](http://automattic.github.io/eventbrite-api/users.html).
 92 | 
 93 | == Changelog ==
 94 | 
 95 | = 1.0.12 - December 12, 2016 =
 96 | * Fix display of Eventbrite ticket iframes.
 97 | * Improve page template handling.
 98 | * Make the full uploaded logo available in the event object.
 99 | 
100 | = 1.0.11 - May 30, 2016 =
101 | * Support the `status` parameter in Eventbrite_Query when displaying private events.
102 | * Have date formats reflect the admin settings.
103 | * Improve the URL format to avoid occasional issues with the Eventbrite API.
104 | 
105 | = 1.0.10 - October 7, 2015 =
106 | * Fix bug from when `Eventbrite_Query` args conflict with the loading URL.
107 | * Fix bugs involving organizer events not owned by the user.
108 | * Add filters for transient names and API responses.
109 | * Fix PHP warnings when certain ticket information is not available.
110 | 
111 | = 1.0.9 - October 4, 2015 =
112 | * Increase timeout for Eventbrite API calls.
113 | * Add a filter for expansions.
114 | 
115 | = 1.0.8 - August 18, 2015 =
116 | * Fix bug where Eventbrite would not load for logged-in users, other than the user that created the Eventbrite connection.
117 | 
118 | = 1.0.7 - August 9, 2015 =
119 | * Add support for the `nopaging` query parameter (props @otterly).
120 | * Add support for the `category_id`, `subcategory_id`, and `format_id` query parameters (props @moust).
121 | 
122 | = 1.0.6 - August 2, 2015 =
123 | * Avoid caching and filtering on invalid API responses.
124 | * Improve rewrite rules flushing on page saves and template changes.
125 | 
126 | = 1.0.5 - April 23, 2015 =
127 | * Add expansions, to handle breaking changes to the API planned for May 13, 2015.
128 | 
129 | = 1.0.4 - April 2, 2015 =
130 | * Update to logo handling; Eventbrite announced a sudden breaking change to happen April 7th, 2015.
131 | * Fix bug affecting detection of logos in events.
132 | 
133 | = 1.0.3 - January 31, 2015 =
134 | * Display Edit link only if user is logged in with appropriate capabilities.
135 | * Only output event logo markup if one exists. Corrects broken image icon in Firefox.
136 | 
137 | = 1.0.2 - January 21, 2015 =
138 | * Add filter for transient expiry.
139 | 
140 | = 1.0.1 - December 12, 2014 =
141 | * Add an anonymous referral code to OAuth connections so Eventbrite can gauge adoption on WordPress.
142 | 
143 | = 1.0 - December 1, 2014 =
144 | * Initial release.
145 | 


--------------------------------------------------------------------------------
/tmpl/compat/twentyeleven/eventbrite-index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * The template for displaying all Eventbrite events (index), and archives (sorted by organizer or venue).
 4 |  */
 5 | 
 6 | get_header(); ?>
 7 | 
 8 | 	<div id="primary">
 9 | 		<div id="content" role="main">
10 | 			<header class="page-header">
11 | 				<h1 class="page-title">
12 | 					<?php the_title(); ?>
13 | 				</h1>
14 | 			</header><!-- .page-header -->
15 | 
16 | 			<?php
17 | 				// Set up and call our Eventbrite query.
18 | 				$events = new Eventbrite_Query( apply_filters( 'eventbrite_query_args', array(
19 | 					// 'display_private' => false, // boolean
20 | 					// 'nopaging' => false,        // boolean
21 | 					// 'limit' => null,            // integer
22 | 					// 'organizer_id' => null,     // integer
23 | 					// 'p' => null,                // integer
24 | 					// 'post__not_in' => null,     // array of integers
25 | 					// 'venue_id' => null,         // integer
26 | 					// 'category_id' => null,      // integer
27 | 					// 'subcategory_id' => null,   // integer
28 | 					// 'format_id' => null,        // integer
29 | 				) ) );
30 | 
31 | 				if ( $events->have_posts() ) :
32 | 					while ( $events->have_posts() ) : $events->the_post(); ?>
33 | 
34 | 						<article id="event-<?php the_ID(); ?>" <?php post_class(); ?>>
35 | 							<header class="entry-header">
36 | 								<?php the_title( sprintf( '<h1 class="entry-title"><a href="%s" rel="bookmark">', esc_url( get_permalink() ) ), '</a></h1>' ); ?>
37 | 
38 | 								<div class="entry-meta">
39 | 									<?php eventbrite_event_meta(); ?>
40 | 								</div><!-- .entry-meta -->
41 | 							</header><!-- .entry-header -->
42 | 
43 | 							<div class="entry-content">
44 | 								<?php eventbrite_ticket_form_widget(); ?>
45 | 							</div><!-- .entry-content -->
46 | 
47 | 							<footer class="entry-meta">
48 | 								<?php eventbrite_edit_post_link( __( 'Edit', 'eventbrite_api' ), '<span class="edit-link">', '</span>' ); ?>
49 | 							</footer><!-- .entry-meta -->
50 | 						</article><!-- #post-## -->
51 | 
52 | 					<?php endwhile;
53 | 
54 | 					// Previous/next post navigation.
55 | 					eventbrite_paging_nav( $events );
56 | 
57 | 				else :
58 | 					// If no content, include the "No posts found" template.
59 | 					get_template_part( 'content', 'none' );
60 | 
61 | 				endif;
62 | 
63 | 				// Return $post to its rightful owner.
64 | 				wp_reset_postdata();
65 | 			?>
66 | 
67 | 		</div><!-- #content -->
68 | 	</div><!-- #primary -->
69 | 
70 | <?php get_sidebar(); ?>
71 | <?php get_footer(); ?>
72 | 


--------------------------------------------------------------------------------
/tmpl/compat/twentyeleven/eventbrite-single.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * The Template for displaying all single Eventbrite events.
 4 |  */
 5 | 
 6 | get_header(); ?>
 7 | 
 8 | 	<div id="primary" class="site-content">
 9 | 		<div id="content" role="main">
10 | 			<?php
11 | 				// Get our event based on the ID passed by query variable.
12 | 				$event = new Eventbrite_Query( array( 'p' => get_query_var( 'eventbrite_id' ) ) );
13 | 
14 | 				if ( $event->have_posts() ) :
15 | 					while ( $event->have_posts() ) : $event->the_post(); ?>
16 | 
17 | 						<article id="event-<?php the_ID(); ?>" <?php post_class(); ?>>
18 | 							<header class="entry-header">
19 | 								<h1 class="entry-title"><?php the_title(); ?></h1>
20 | 
21 | 								<div class="entry-meta">
22 | 									<?php eventbrite_event_meta(); ?>
23 | 								</div><!-- .entry-meta -->
24 | 							</header><!-- .entry-header -->
25 | 
26 | 							<div class="entry-content">
27 | 								<?php the_content(); ?>
28 | 
29 | 								<?php eventbrite_ticket_form_widget(); ?>
30 | 							</div><!-- .entry-content -->
31 | 
32 | 							<footer class="entry-meta">
33 | 								<?php eventbrite_edit_post_link( __( 'Edit', 'eventbrite_api' ), '<span class="edit-link">', '</span>' ); ?>
34 | 							</footer>
35 | 						</article><!-- #post-## -->
36 | 
37 | 					<?php endwhile;
38 | 
39 | 				else :
40 | 					// If no content, include the "No posts found" template.
41 | 					get_template_part( 'content', 'none' );
42 | 
43 | 				endif;
44 | 
45 | 				// Return $post to its rightful owner.
46 | 				wp_reset_postdata();
47 | 			?>
48 | 		</div><!-- #content -->
49 | 	</div><!-- #primary -->
50 | 
51 | <?php get_footer(); ?>
52 | 


--------------------------------------------------------------------------------
/tmpl/compat/twentyeleven/eventbrite-style.css:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Eventbrite styles for Twenty Eleven.
 3 |  *
 4 |  * @package Eventbrite_API
 5 |  */
 6 | 
 7 | .single-event .screen-reader-text,
 8 | .archive-eventbrite .screen-reader-text {
 9 | 	clip: rect(1px, 1px, 1px, 1px);
10 | 	height: 1px;
11 | 	overflow: hidden;
12 | 	position: absolute !important;
13 | 	width: 1px;
14 | }
15 | 
16 | .archive-eventbrite .nav-links {
17 | 	text-align: center;
18 | }
19 | 
20 | .archive-eventbrite .nav-links .current {
21 | 	color: #666;
22 | 	font-size: 12px;
23 | 	font-weight: bold;
24 | 	line-height: 2.2em;
25 | }
26 | 
27 | .archive-eventbrite .nav-links .page-numbers {
28 | 	padding: 0 7px;
29 | }


--------------------------------------------------------------------------------
/tmpl/compat/twentyfifteen/eventbrite-index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * The template for displaying all Eventbrite events (index), and archives (sorted by organizer or venue).
 4 |  */
 5 | 
 6 | get_header(); ?>
 7 | 
 8 | 	<section id="primary" class="content-area">
 9 | 		<main id="main" class="site-main" role="main">
10 | 			<header class="page-header">
11 | 				<h1 class="page-title">
12 | 					<?php the_title(); ?>
13 | 				</h1>
14 | 			</header><!-- .page-header -->
15 | 
16 | 			<?php
17 | 				// Set up and call our Eventbrite query.
18 | 				$events = new Eventbrite_Query( apply_filters( 'eventbrite_query_args', array(
19 | 					// 'display_private' => false, // boolean
20 | 					// 'nopaging' => false,        // boolean
21 | 					// 'limit' => null,            // integer
22 | 					// 'organizer_id' => null,     // integer
23 | 					// 'p' => null,                // integer
24 | 					// 'post__not_in' => null,     // array of integers
25 | 					// 'venue_id' => null,         // integer
26 | 					// 'category_id' => null,      // integer
27 | 					// 'subcategory_id' => null,   // integer
28 | 					// 'format_id' => null,        // integer
29 | 				) ) );
30 | 
31 | 				if ( $events->have_posts() ) :
32 | 					while ( $events->have_posts() ) : $events->the_post(); ?>
33 | 
34 | 						<article id="event-<?php the_ID(); ?>" <?php post_class(); ?>>
35 | 							<?php the_post_thumbnail(); ?>
36 | 
37 | 							<header class="entry-header">
38 | 
39 | 								<?php the_title( sprintf( '<h2 class="entry-title"><a href="%s" rel="bookmark">', esc_url( get_permalink() ) ), '</a></h2>' ); ?>
40 | 
41 | 								<div class="entry-meta">
42 | 									<?php eventbrite_event_meta(); ?>
43 | 								</div><!-- .entry-meta -->
44 | 							</header><!-- .entry-header -->
45 | 
46 | 							<div class="entry-content">
47 | 								<?php eventbrite_ticket_form_widget(); ?>
48 | 							</div><!-- .entry-content -->
49 | 
50 | 							<footer class="entry-footer">
51 | 								<?php eventbrite_edit_post_link( __( 'Edit', 'eventbrite_api' ), '<span class="edit-link">', '</span>' ); ?>
52 | 							</footer><!-- .entry-footer -->
53 | 						</article><!-- #post-## -->
54 | 
55 | 					<?php endwhile;
56 | 
57 | 					// Previous/next post navigation.
58 | 					eventbrite_paging_nav( $events );
59 | 
60 | 				else :
61 | 					// If no content, include the "No posts found" template.
62 | 					get_template_part( 'content', 'none' );
63 | 
64 | 				endif;
65 | 
66 | 				// Return $post to its rightful owner.
67 | 				wp_reset_postdata();
68 | 			?>
69 | 
70 | 		</main><!-- #main -->
71 | 	</section><!-- #primary -->
72 | 
73 | <?php get_sidebar(); ?>
74 | <?php get_footer(); ?>
75 | 


--------------------------------------------------------------------------------
/tmpl/compat/twentyfifteen/eventbrite-single.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * The Template for displaying all single Eventbrite events.
 4 |  */
 5 | 
 6 | get_header(); ?>
 7 | 
 8 | 	<div id="primary" class="content-area">
 9 | 		<main id="main" class="site-main" role="main">
10 | 			<?php
11 | 				// Get our event based on the ID passed by query variable.
12 | 				$event = new Eventbrite_Query( array( 'p' => get_query_var( 'eventbrite_id' ) ) );
13 | 
14 | 				if ( $event->have_posts() ) :
15 | 					while ( $event->have_posts() ) : $event->the_post(); ?>
16 | 
17 | 						<article id="event-<?php the_ID(); ?>" <?php post_class(); ?>>
18 | 							<div class="post-thumbnail">
19 | 								<?php the_post_thumbnail(); ?>
20 | 							</div>
21 | 
22 | 							<header class="entry-header">
23 | 
24 | 								<h1 class="entry-title"><?php the_title(); ?></h1>
25 | 
26 | 								<div class="entry-meta">
27 | 									<?php eventbrite_event_meta(); ?>
28 | 								</div><!-- .entry-meta -->
29 | 							</header><!-- .entry-header -->
30 | 
31 | 							<div class="entry-content">
32 | 								<?php the_content(); ?>
33 | 
34 | 								<?php eventbrite_ticket_form_widget(); ?>
35 | 							</div><!-- .entry-content -->
36 | 
37 | 							<footer class="entry-footer">
38 | 								<?php eventbrite_edit_post_link( __( 'Edit', 'eventbrite_api' ), '<span class="edit-link">', '</span>' ); ?>
39 | 							</footer><!-- .entry-footer -->
40 | 						</article><!-- #post-## -->
41 | 
42 | 					<?php endwhile;
43 | 
44 | 				else :
45 | 					// If no content, include the "No posts found" template.
46 | 					get_template_part( 'content', 'none' );
47 | 
48 | 				endif;
49 | 
50 | 				// Return $post to its rightful owner.
51 | 				wp_reset_postdata();
52 | 			?>
53 | 		</main><!-- #main -->
54 | 	</div><!-- #primary -->
55 | 
56 | <?php get_sidebar(); ?>
57 | <?php get_footer(); ?>
58 | 


--------------------------------------------------------------------------------
/tmpl/compat/twentyfifteen/eventbrite-style.css:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Eventbrite styles for Twenty Fifteen.
  3 |  *
  4 |  * @package Eventbrite_API
  5 |  */
  6 | 
  7 | .eventbrite-event .entry-title {
  8 | 	margin-bottom: 0.25em;
  9 | }
 10 | 
 11 | .eventbrite-event .entry-meta,
 12 | .eventbrite-event .entry-meta a {
 13 | 	color: #707070;
 14 | 	color: rgba(51, 51, 51, 0.7);
 15 | 	font-family: "Noto Sans", sans-serif;
 16 | 	font-size: 12px;
 17 | 	font-size: 1.2rem;
 18 | 	line-height: 1.5;
 19 | 	margin-bottom: 2em;
 20 | }
 21 | 
 22 | .eventbrite-event .entry-meta a:hover,
 23 | .eventbrite-event .entry-meta a:focus {
 24 | 	color: #333;
 25 | }
 26 | 
 27 | .eventbrite-event .event-time:before,
 28 | .eventbrite-event .event-organizer-text:before,
 29 | .eventbrite-event .event-venue-text:before,
 30 | .eventbrite-event .event-details-text:before {
 31 | 	-moz-osx-font-smoothing: grayscale;
 32 | 	-webkit-font-smoothing: antialiased;
 33 | 	display: inline-block;
 34 | 	font-family: "Genericons";
 35 | 	font-size: 16px;
 36 | 	font-style: normal;
 37 | 	font-weight: normal;
 38 | 	font-variant: normal;
 39 | 	line-height: 1;
 40 | 	margin-right: 2px;
 41 | 	position: relative;
 42 | 	speak: none;
 43 | 	text-align: center;
 44 | 	text-decoration: inherit;
 45 | 	text-transform: none;
 46 | 	vertical-align: top;
 47 | }
 48 | 
 49 | .eventbrite-event .event-time:before {
 50 | 	content: "\f307";
 51 | }
 52 | 
 53 | .eventbrite-event .event-organizer-text:before {
 54 | 	content: "\f304";
 55 | }
 56 | 
 57 | .eventbrite-event .event-venue-text:before {
 58 | 	content: "\f417";
 59 | }
 60 | 
 61 | .eventbrite-event .event-details-text:before {
 62 | 	content: "\f455";
 63 | }
 64 | 
 65 | .eventbrite-event .sep {
 66 | 	display: none;
 67 | }
 68 | 
 69 | .eventbrite-event .event-time,
 70 | .eventbrite-event .event-organizer,
 71 | .eventbrite-event .event-venue,
 72 | .eventbrite-event .event-details {
 73 | 	margin-right: 1em;
 74 | }
 75 | 
 76 | @media screen and (min-width: 46.25em) {
 77 | 	.eventbrite-event .entry-meta,
 78 | 	.eventbrite-event .entry-meta a {
 79 | 		font-size: 14px;
 80 | 		font-size: 1.4rem;
 81 | 	}
 82 | 
 83 | 	.eventbrite-event .event-time:before,
 84 | 	.eventbrite-event .event-organizer-text:before,
 85 | 	.eventbrite-event .event-venue-text:before,
 86 | 	.eventbrite-event .event-details-text:before {
 87 | 		top: 3px;
 88 | 	}
 89 | }
 90 | 
 91 | @media screen and (min-width: 55em) {
 92 | 	.eventbrite-event .entry-meta,
 93 | 	.eventbrite-event .entry-meta a {
 94 | 		font-size: 16px;
 95 | 		font-size: 1.6rem;
 96 | 	}
 97 | 
 98 | 	.eventbrite-event .event-time:before,
 99 | 	.eventbrite-event .event-organizer-text:before,
100 | 	.eventbrite-event .event-venue-text:before,
101 | 	.eventbrite-event .event-details-text:before {
102 | 		top: 4px;
103 | 	}
104 | }
105 | 
106 | @media screen and (min-width: 59.6875em) {
107 | 	.eventbrite-event .entry-meta,
108 | 	.eventbrite-event .entry-meta a {
109 | 		font-size: 12px;
110 | 		font-size: 1.2rem;
111 | 	}
112 | 
113 | 	.eventbrite-event .event-time:before,
114 | 	.eventbrite-event .event-organizer-text:before,
115 | 	.eventbrite-event .event-venue-text:before,
116 | 	.eventbrite-event .event-details-text:before {
117 | 		top: 0;
118 | 	}
119 | }
120 | 
121 | @media screen and (min-width: 68.75em) {
122 | 	.eventbrite-event .entry-meta,
123 | 	.eventbrite-event .entry-meta a {
124 | 		font-size: 14px;
125 | 		font-size: 1.4rem;
126 | 	}
127 | 
128 | 	.eventbrite-event .event-time:before,
129 | 	.eventbrite-event .event-organizer-text:before,
130 | 	.eventbrite-event .event-venue-text:before,
131 | 	.eventbrite-event .event-details-text:before {
132 | 		top: 3px;
133 | 	}
134 | }
135 | 
136 | @media screen and (min-width: 77.5em) {
137 | 	.eventbrite-event .entry-meta,
138 | 	.eventbrite-event .entry-meta a {
139 | 		font-size: 16px;
140 | 		font-size: 1.6rem;
141 | 	}
142 | 
143 | 	.eventbrite-event .event-time:before,
144 | 	.eventbrite-event .event-organizer-text:before,
145 | 	.eventbrite-event .event-venue-text:before,
146 | 	.eventbrite-event .event-details-text:before {
147 | 		top: 4px;
148 | 	}
149 | }
150 | 


--------------------------------------------------------------------------------
/tmpl/compat/twentyfourteen/eventbrite-index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * The template for displaying all Eventbrite events (index), and archives (sorted by organizer or venue).
 4 |  */
 5 | 
 6 | get_header(); ?>
 7 | 
 8 | <div id="main-content" class="main-content">
 9 | 	<div id="primary" class="content-area">
10 | 		<div id="content" class="site-content" role="main">
11 | 			<header class="page-header">
12 | 				<h1 class="page-title">
13 | 					<?php the_title(); ?>
14 | 				</h1>
15 | 			</header><!-- .page-header -->
16 | 
17 | 			<?php
18 | 				// Set up and call our Eventbrite query.
19 | 				$events = new Eventbrite_Query( apply_filters( 'eventbrite_query_args', array(
20 | 					// 'display_private' => false, // boolean
21 | 					// 'nopaging' => false,        // boolean
22 | 					// 'limit' => null,            // integer
23 | 					// 'organizer_id' => null,     // integer
24 | 					// 'p' => null,                // integer
25 | 					// 'post__not_in' => null,     // array of integers
26 | 					// 'venue_id' => null,         // integer
27 | 					// 'category_id' => null,      // integer
28 | 					// 'subcategory_id' => null,   // integer
29 | 					// 'format_id' => null,        // integer
30 | 				) ) );
31 | 
32 | 				if ( $events->have_posts() ) :
33 | 					while ( $events->have_posts() ) : $events->the_post(); ?>
34 | 
35 | 						<article id="event-<?php the_ID(); ?>" <?php post_class(); ?>>
36 | 							<?php the_post_thumbnail(); ?>
37 | 
38 | 							<header class="entry-header">
39 | 
40 | 								<?php the_title( sprintf( '<h1 class="entry-title"><a href="%s" rel="bookmark">', esc_url( get_permalink() ) ), '</a></h1>' ); ?>
41 | 
42 | 								<div class="entry-meta">
43 | 									<?php eventbrite_event_meta(); ?>
44 | 
45 | 									<?php eventbrite_edit_post_link( __( 'Edit', 'eventbrite_api' ), '<span class="edit-link">', '</span>' ); ?>
46 | 								</div><!-- .entry-meta -->
47 | 							</header><!-- .entry-header -->
48 | 
49 | 							<div class="entry-content">
50 | 								<?php eventbrite_ticket_form_widget(); ?>
51 | 							</div><!-- .entry-content -->
52 | 						</article><!-- #event-## -->
53 | 
54 | 					<?php endwhile;
55 | 
56 | 					// Previous/next post navigation.
57 | 					eventbrite_paging_nav( $events );
58 | 
59 | 				else :
60 | 					// If no content, include the "No posts found" template.
61 | 					get_template_part( 'content', 'none' );
62 | 
63 | 				endif;
64 | 
65 | 				// Return $post to its rightful owner.
66 | 				wp_reset_postdata();
67 | 			?>
68 | 
69 | 		</div><!-- #content -->
70 | 	</div><!-- #primary -->
71 | 	<?php get_sidebar( 'content' ); ?>
72 | </div><!-- #main-content -->
73 | 
74 | <?php
75 | get_sidebar();
76 | get_footer();
77 | 


--------------------------------------------------------------------------------
/tmpl/compat/twentyfourteen/eventbrite-single.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * The Template for displaying all single Eventbrite events.
 4 |  */
 5 | 
 6 | get_header(); ?>
 7 | 
 8 | 	<div id="primary" class="content-area">
 9 | 		<div id="content" class="site-content" role="main">
10 | 			<?php
11 | 				// Get our event based on the ID passed by query variable.
12 | 				$event = new Eventbrite_Query( array( 'p' => get_query_var( 'eventbrite_id' ) ) );
13 | 
14 | 				if ( $event->have_posts() ) :
15 | 					while ( $event->have_posts() ) : $event->the_post(); ?>
16 | 
17 | 						<article id="event-<?php the_ID(); ?>" <?php post_class(); ?>>
18 | 							<div class="post-thumbnail">
19 | 								<?php the_post_thumbnail(); ?>
20 | 							</div>
21 | 
22 | 							<header class="entry-header">
23 | 
24 | 								<h1 class="entry-title"><?php the_title(); ?></h1>
25 | 
26 | 								<div class="entry-meta">
27 | 									<?php eventbrite_event_meta(); ?>
28 | 
29 | 									<?php eventbrite_edit_post_link( __( 'Edit', 'eventbrite_api' ), '<span class="edit-link">', '</span>' ); ?>
30 | 								</div><!-- .entry-meta -->
31 | 							</header><!-- .entry-header -->
32 | 
33 | 							<div class="entry-content">
34 | 								<?php the_content(); ?>
35 | 
36 | 								<?php eventbrite_ticket_form_widget(); ?>
37 | 							</div><!-- .entry-content -->
38 | 						</article><!-- #event-## -->
39 | 
40 | 					<?php endwhile;
41 | 
42 | 				else :
43 | 					// If no content, include the "No posts found" template.
44 | 					get_template_part( 'content', 'none' );
45 | 
46 | 				endif;
47 | 
48 | 				// Return $post to its rightful owner.
49 | 				wp_reset_postdata();
50 | 			?>
51 | 		</div><!-- #content -->
52 | 	</div><!-- #primary -->
53 | 
54 | <?php
55 | get_sidebar( 'content' );
56 | get_sidebar();
57 | get_footer();
58 | 


--------------------------------------------------------------------------------
/tmpl/compat/twentyfourteen/eventbrite-style.css:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Eventbrite styles for Twenty Fourteen.
 3 |  *
 4 |  * @package Eventbrite_API
 5 |  */
 6 | 
 7 | .eventbrite-event .event-time:before,
 8 | .eventbrite-event .event-organizer-text:before,
 9 | .eventbrite-event .event-venue-text:before,
10 | .eventbrite-event .event-details-text:before {
11 | 	-webkit-font-smoothing: antialiased;
12 | 	display: inline-block;
13 | 	font: normal 16px/1 Genericons;
14 | 	text-decoration: inherit;
15 | 	vertical-align: text-bottom;
16 | }
17 | 
18 | .eventbrite-event .event-time:before {
19 | 	content: "\f303";
20 | }
21 | 
22 | .eventbrite-event .event-organizer-text:before {
23 | 	content: "\f304";
24 | }
25 | 
26 | .eventbrite-event .event-venue-text:before {
27 | 	content: "\f417";
28 | }
29 | 
30 | .eventbrite-event .event-details-text:before {
31 | 	content: "\f455";
32 | }
33 | 
34 | .eventbrite-event .sep {
35 | 	display: none;
36 | }


--------------------------------------------------------------------------------
/tmpl/compat/twentyten/eventbrite-index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * The template for displaying all Eventbrite events (index), and archives (sorted by organizer or venue).
 4 |  */
 5 | 
 6 | get_header(); ?>
 7 | 
 8 | 		<div id="container">
 9 | 			<div id="content" role="main">
10 | 				<h1 class="page-title">
11 | 					<?php the_title(); ?>
12 | 				</h1>
13 | 
14 | 				<?php
15 | 					// Set up and call our Eventbrite query.
16 | 					$events = new Eventbrite_Query( apply_filters( 'eventbrite_query_args', array(
17 | 						// 'display_private' => false, // boolean
18 | 						// 'nopaging' => false,        // boolean
19 | 						// 'limit' => null,            // integer
20 | 						// 'organizer_id' => null,     // integer
21 | 						// 'p' => null,                // integer
22 | 						// 'post__not_in' => null,     // array of integers
23 | 						// 'venue_id' => null,         // integer
24 | 						// 'category_id' => null,      // integer
25 | 						// 'subcategory_id' => null,   // integer
26 | 						// 'format_id' => null,        // integer
27 | 					) ) );
28 | 
29 | 					if ( $events->have_posts() ) :
30 | 						while ( $events->have_posts() ) : $events->the_post(); ?>
31 | 
32 | 							<div id="event-<?php the_ID(); ?>" <?php post_class(); ?>>
33 | 								<?php the_title( sprintf( '<h2 class="entry-title"><a href="%s" rel="bookmark">', esc_url( get_permalink() ) ), '</a></h2>' ); ?>
34 | 
35 | 								<div class="entry-meta">
36 | 									<?php eventbrite_event_meta(); ?>
37 | 								</div><!-- .entry-meta -->
38 | 
39 | 								<div class="entry-content">
40 | 									<?php eventbrite_ticket_form_widget(); ?>
41 | 								</div><!-- .entry-content -->
42 | 
43 | 								<div class="entry-utility">
44 | 									<?php eventbrite_edit_post_link( __( 'Edit', 'eventbrite_api' ), '<span class="edit-link">', '</span>' ); ?>
45 | 								</div><!-- .entry-utility -->
46 | 							</div><!-- #post-## -->
47 | 
48 | 						<?php endwhile;
49 | 
50 | 						// Previous/next post navigation.
51 | 						eventbrite_paging_nav( $events );
52 | 
53 | 					else :
54 | 						// If no content, include the "No posts found" template.
55 | 						get_template_part( 'content', 'none' );
56 | 
57 | 					endif;
58 | 
59 | 					// Return $post to its rightful owner.
60 | 					wp_reset_postdata();
61 | 				?>
62 | 			</div><!-- #content -->
63 | 		</div><!-- #container -->
64 | 
65 | <?php get_sidebar(); ?>
66 | <?php get_footer(); ?>
67 | 


--------------------------------------------------------------------------------
/tmpl/compat/twentyten/eventbrite-single.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * The template for displaying all Eventbrite events (index), and archives (sorted by organizer or venue).
 4 |  */
 5 | 
 6 | get_header(); ?>
 7 | 
 8 | 		<div id="container">
 9 | 			<div id="content" role="main">
10 | 				<?php
11 | 					// Get our event based on the ID passed by query variable.
12 | 					$event = new Eventbrite_Query( array( 'p' => get_query_var( 'eventbrite_id' ) ) );
13 | 
14 | 					if ( $event->have_posts() ) :
15 | 						while ( $event->have_posts() ) : $event->the_post(); ?>
16 | 
17 | 							<div id="event-<?php the_ID(); ?>" <?php post_class(); ?>>
18 | 								<h2 class="entry-title"><?php the_title(); ?></h2>
19 | 
20 | 								<div class="entry-meta">
21 | 									<?php eventbrite_event_meta(); ?>
22 | 								</div><!-- .entry-meta -->
23 | 
24 | 								<div class="entry-content">
25 | 									<?php the_content(); ?>
26 | 
27 | 									<?php eventbrite_ticket_form_widget(); ?>
28 | 								</div><!-- .entry-content -->
29 | 
30 | 								<div class="entry-utility">
31 | 									<?php eventbrite_edit_post_link( __( 'Edit', 'eventbrite_api' ), '<span class="edit-link">', '</span>' ); ?>
32 | 								</div><!-- .entry-utility -->
33 | 							</div><!-- #post-## -->
34 | 
35 | 						<?php endwhile;
36 | 
37 | 					else :
38 | 						// If no content, include the "No posts found" template.
39 | 						get_template_part( 'content', 'none' );
40 | 
41 | 					endif;
42 | 
43 | 					// Return $post to its rightful owner.
44 | 					wp_reset_postdata();
45 | 				?>
46 | 			</div><!-- #content -->
47 | 		</div><!-- #container -->
48 | 
49 | <?php get_sidebar(); ?>
50 | <?php get_footer(); ?>
51 | 


--------------------------------------------------------------------------------
/tmpl/compat/twentyten/eventbrite-style.css:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Eventbrite styles for Twenty Ten.
 3 |  *
 4 |  * @package Eventbrite_API
 5 |  */
 6 | 
 7 | .eventbrite-event .sep {
 8 | 	display: none;
 9 | }
10 | .eventbrite-event .event-venue:before,
11 | .eventbrite-event .event-organizer:before,
12 | .eventbrite-event .event-details:before {
13 | 	content: ' | ';
14 | }
15 | .archive-eventbrite .nav-links {
16 | 	text-align: center;
17 | }
18 | .archive-eventbrite .nav-links .page-numbers {
19 | 	display: inline-block;
20 | 	padding: 8px 12px;
21 | }
22 | .archive-eventbrite .nav-links a:hover {
23 | 	background-color: #f1f1f1;
24 | }
25 | .archive-eventbrite .nav-links .page-numbers.current {
26 | 	background-color: #f1f1f1;
27 | 	color: #000;
28 | 	font-weight: bold;
29 | }


--------------------------------------------------------------------------------
/tmpl/compat/twentythirteen/eventbrite-index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * The template for displaying all Eventbrite events (index), and archives (sorted by organizer or venue).
 4 |  */
 5 | 
 6 | get_header(); ?>
 7 | 
 8 | 	<div id="primary" class="content-area">
 9 | 		<div id="content" class="site-content" role="main">
10 | 			<header class="archive-header">
11 | 				<h1 class="archive-title">
12 | 					<?php the_title(); ?>
13 | 				</h1>
14 | 			</header><!-- .archive-header -->
15 | 
16 | 			<?php
17 | 				// Set up and call our Eventbrite query.
18 | 				$events = new Eventbrite_Query( apply_filters( 'eventbrite_query_args', array(
19 | 					// 'display_private' => false, // boolean
20 | 					// 'nopaging' => false,        // boolean
21 | 					// 'limit' => null,            // integer
22 | 					// 'organizer_id' => null,     // integer
23 | 					// 'p' => null,                // integer
24 | 					// 'post__not_in' => null,     // array of integers
25 | 					// 'venue_id' => null,         // integer
26 | 					// 'category_id' => null,      // integer
27 | 					// 'subcategory_id' => null,   // integer
28 | 					// 'format_id' => null,        // integer
29 | 				) ) );
30 | 
31 | 				if ( $events->have_posts() ) :
32 | 					while ( $events->have_posts() ) : $events->the_post(); ?>
33 | 
34 | 						<article id="event-<?php the_ID(); ?>" <?php post_class(); ?>>
35 | 							<header class="entry-header">
36 | 								<div class="entry-thumbnail">
37 | 									<?php the_post_thumbnail(); ?>
38 | 								</div>
39 | 
40 | 								<?php the_title( sprintf( '<h1 class="entry-title"><a href="%s" rel="bookmark">', esc_url( get_permalink() ) ), '</a></h1>' ); ?>
41 | 
42 | 								<div class="entry-meta">
43 | 									<?php eventbrite_event_meta(); ?>
44 | 
45 | 									<?php eventbrite_edit_post_link( __( 'Edit', 'eventbrite_api' ), '<span class="edit-link">', '</span>' ); ?>
46 | 								</div><!-- .entry-meta -->
47 | 							</header><!-- .entry-header -->
48 | 
49 | 							<div class="entry-content">
50 | 								<?php eventbrite_ticket_form_widget(); ?>
51 | 							</div><!-- .entry-content -->
52 | 						</article><!-- #post-## -->
53 | 
54 | 					<?php endwhile;
55 | 
56 | 					// Previous/next post navigation.
57 | 					eventbrite_paging_nav( $events );
58 | 
59 | 				else :
60 | 					// If no content, include the "No posts found" template.
61 | 					get_template_part( 'content', 'none' );
62 | 
63 | 				endif;
64 | 
65 | 				// Return $post to its rightful owner.
66 | 				wp_reset_postdata();
67 | 			?>
68 | 
69 | 		</div><!-- #content -->
70 | 	</div><!-- #primary -->
71 | 
72 | <?php get_sidebar(); ?>
73 | <?php get_footer(); ?>
74 | 


--------------------------------------------------------------------------------
/tmpl/compat/twentythirteen/eventbrite-single.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * The Template for displaying all single Eventbrite events.
 4 |  */
 5 | 
 6 | get_header(); ?>
 7 | 
 8 | 	<div id="primary" class="content-area">
 9 | 		<div id="content" class="site-content" role="main">
10 | 			<?php
11 | 				// Get our event based on the ID passed by query variable.
12 | 				$event = new Eventbrite_Query( array( 'p' => get_query_var( 'eventbrite_id' ) ) );
13 | 
14 | 				if ( $event->have_posts() ) :
15 | 					while ( $event->have_posts() ) : $event->the_post(); ?>
16 | 
17 | 						<article id="event-<?php the_ID(); ?>" <?php post_class(); ?>>
18 | 							<header class="entry-header">
19 | 								<div class="entry-thumbnail">
20 | 									<?php the_post_thumbnail(); ?>
21 | 								</div>
22 | 
23 | 								<h1 class="entry-title"><?php the_title(); ?></h1>
24 | 
25 | 								<div class="entry-meta">
26 | 									<?php eventbrite_event_meta(); ?>
27 | 
28 | 									<?php eventbrite_edit_post_link( __( 'Edit', 'eventbrite_api' ), '<span class="edit-link">', '</span>' ); ?>
29 | 								</div><!-- .entry-meta -->
30 | 							</header><!-- .entry-header -->
31 | 
32 | 							<div class="entry-content">
33 | 								<?php the_content(); ?>
34 | 
35 | 								<?php eventbrite_ticket_form_widget(); ?>
36 | 							</div><!-- .entry-content -->
37 | 						</article><!-- #post-## -->
38 | 
39 | 					<?php endwhile;
40 | 
41 | 				else :
42 | 					// If no content, include the "No posts found" template.
43 | 					get_template_part( 'content', 'none' );
44 | 
45 | 				endif;
46 | 
47 | 				// Return $post to its rightful owner.
48 | 				wp_reset_postdata();
49 | 			?>
50 | 		</div><!-- #content -->
51 | 	</div><!-- #primary -->
52 | 
53 | <?php get_sidebar(); ?>
54 | <?php get_footer(); ?>
55 | 


--------------------------------------------------------------------------------
/tmpl/compat/twentythirteen/eventbrite-style.css:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Eventbrite styles for Twenty Thirteen.
 3 |  *
 4 |  * @package Eventbrite_API
 5 |  */
 6 | 
 7 | .eventbrite-event .event-time:before,
 8 | .eventbrite-event .event-organizer-text:before,
 9 | .eventbrite-event .event-venue-text:before,
10 | .eventbrite-event .event-details-text:before {
11 | 	-webkit-font-smoothing: antialiased;
12 | 	display: inline-block;
13 | 	font: normal 16px/1 Genericons;
14 | 	text-decoration: inherit;
15 | 	vertical-align: text-bottom;
16 | }
17 | 
18 | .eventbrite-event .event-time:before {
19 | 	content: "\f303";
20 | }
21 | 
22 | .eventbrite-event .event-organizer-text:before {
23 | 	content: "\f304";
24 | }
25 | 
26 | .eventbrite-event .event-venue-text:before {
27 | 	content: "\f417";
28 | }
29 | 
30 | .eventbrite-event .event-details-text:before {
31 | 	content: "\f455";
32 | }
33 | 
34 | .eventbrite-event .sep {
35 | 	display: none;
36 | }


--------------------------------------------------------------------------------
/tmpl/compat/twentytwelve/eventbrite-index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * The template for displaying all Eventbrite events (index), and archives (sorted by organizer or venue).
 4 |  */
 5 | 
 6 | get_header(); ?>
 7 | 
 8 | 	<div id="primary" class="site-content">
 9 | 		<div id="content" role="main">
10 | 			<header class="archive-header">
11 | 				<h1 class="archive-title">
12 | 					<?php the_title(); ?>
13 | 				</h1>
14 | 			</header><!-- .archive-header -->
15 | 
16 | 			<?php
17 | 				// Set up and call our Eventbrite query.
18 | 				$events = new Eventbrite_Query( apply_filters( 'eventbrite_query_args', array(
19 | 					// 'display_private' => false, // boolean
20 | 					// 'nopaging' => false,        // boolean
21 | 					// 'limit' => null,            // integer
22 | 					// 'organizer_id' => null,     // integer
23 | 					// 'p' => null,                // integer
24 | 					// 'post__not_in' => null,     // array of integers
25 | 					// 'venue_id' => null,         // integer
26 | 					// 'category_id' => null,      // integer
27 | 					// 'subcategory_id' => null,   // integer
28 | 					// 'format_id' => null,        // integer
29 | 				) ) );
30 | 
31 | 				if ( $events->have_posts() ) :
32 | 					while ( $events->have_posts() ) : $events->the_post(); ?>
33 | 
34 | 						<article id="event-<?php the_ID(); ?>" <?php post_class(); ?>>
35 | 							<header class="entry-header">
36 | 								<?php the_post_thumbnail(); ?>
37 | 
38 | 								<?php the_title( sprintf( '<h1 class="entry-title"><a href="%s" rel="bookmark">', esc_url( get_permalink() ) ), '</a></h1>' ); ?>
39 | 
40 | 								<div class="entry-meta">
41 | 									<?php eventbrite_event_meta(); ?>
42 | 
43 | 									<?php eventbrite_edit_post_link( __( 'Edit', 'eventbrite_api' ), '<span class="sep"> &middot; </span><span class="edit-link">', '</span>' ); ?>
44 | 								</div><!-- .entry-meta -->
45 | 							</header><!-- .entry-header -->
46 | 
47 | 							<div class="entry-content">
48 | 								<?php eventbrite_ticket_form_widget(); ?>
49 | 							</div><!-- .entry-content -->
50 | 						</article><!-- #post-## -->
51 | 
52 | 					<?php endwhile;
53 | 
54 | 					// Previous/next post navigation.
55 | 					eventbrite_paging_nav( $events );
56 | 
57 | 				else :
58 | 					// If no content, include the "No posts found" template.
59 | 					get_template_part( 'content', 'none' );
60 | 
61 | 				endif;
62 | 
63 | 				// Return $post to its rightful owner.
64 | 				wp_reset_postdata();
65 | 			?>
66 | 
67 | 		</div><!-- #content -->
68 | 	</div><!-- #primary -->
69 | 
70 | <?php get_sidebar(); ?>
71 | <?php get_footer(); ?>
72 | 


--------------------------------------------------------------------------------
/tmpl/compat/twentytwelve/eventbrite-single.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * The Template for displaying all single Eventbrite events.
 4 |  */
 5 | 
 6 | get_header(); ?>
 7 | 
 8 | 	<div id="primary" class="site-content">
 9 | 		<div id="content" role="main">
10 | 			<?php
11 | 				// Get our event based on the ID passed by query variable.
12 | 				$event = new Eventbrite_Query( array( 'p' => get_query_var( 'eventbrite_id' ) ) );
13 | 
14 | 				if ( $event->have_posts() ) :
15 | 					while ( $event->have_posts() ) : $event->the_post(); ?>
16 | 
17 | 						<article id="event-<?php the_ID(); ?>" <?php post_class(); ?>>
18 | 							<header class="entry-header">
19 | 								<?php the_post_thumbnail(); ?>
20 | 
21 | 								<h1 class="entry-title"><?php the_title(); ?></h1>
22 | 
23 | 								<div class="entry-meta">
24 | 									<?php eventbrite_event_meta(); ?>
25 | 
26 | 									<?php eventbrite_edit_post_link( __( 'Edit', 'eventbrite_api' ), '<span class="sep"> &middot; </span><span class="edit-link">', '</span>' ); ?>
27 | 								</div><!-- .entry-meta -->
28 | 							</header><!-- .entry-header -->
29 | 
30 | 							<div class="entry-content">
31 | 								<?php the_content(); ?>
32 | 
33 | 								<?php eventbrite_ticket_form_widget(); ?>
34 | 							</div><!-- .entry-content -->
35 | 						</article><!-- #post-## -->
36 | 
37 | 					<?php endwhile;
38 | 
39 | 				else :
40 | 					// If no content, include the "No posts found" template.
41 | 					get_template_part( 'content', 'none' );
42 | 
43 | 				endif;
44 | 
45 | 				// Return $post to its rightful owner.
46 | 				wp_reset_postdata();
47 | 			?>
48 | 		</div><!-- #content -->
49 | 	</div><!-- #primary -->
50 | 
51 | <?php get_sidebar(); ?>
52 | <?php get_footer(); ?>
53 | 


--------------------------------------------------------------------------------
/tmpl/compat/twentytwelve/eventbrite-style.css:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Eventbrite styles for Twenty Twelve.
 3 |  *
 4 |  * @package Eventbrite_API
 5 |  */
 6 | 
 7 | .eventbrite-event .entry-meta {
 8 | 	margin-top: 24px;
 9 | 	margin-top: 1.714285714rem;
10 | 	font-size: 13px;
11 | 	font-size: 0.928571429rem;
12 | 	line-height: 1.846153846;
13 | 	color: #757575;
14 | }
15 | 
16 | .eventbrite-event .entry-meta a {
17 | 	color: #757575;
18 | }
19 | 
20 | .eventbrite-event iframe {
21 | 	margin-bottom: 0;
22 | }


--------------------------------------------------------------------------------
/tmpl/eventbrite-index.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Template Name: Eventbrite Events
 4 |  */
 5 | 
 6 | get_header(); ?>
 7 | 
 8 | 	<div id="primary" class="content-area">
 9 | 		<main id="main" class="site-main" role="main">
10 | 			<header class="page-header">
11 | 				<h1 class="page-title">
12 | 					<?php the_title(); ?>
13 | 				</h1>
14 | 			</header><!-- .page-header -->
15 | 
16 | 			<?php
17 | 				// Set up and call our Eventbrite query.
18 | 				$events = new Eventbrite_Query( apply_filters( 'eventbrite_query_args', array(
19 | 					// 'display_private' => false, // boolean
20 | 					// 'status' => 'live',         // string (only available for display_private true)
21 | 					// 'nopaging' => false,        // boolean
22 | 					// 'limit' => null,            // integer
23 | 					// 'organizer_id' => null,     // integer
24 | 					// 'p' => null,                // integer
25 | 					// 'post__not_in' => null,     // array of integers
26 | 					// 'venue_id' => null,         // integer
27 | 					// 'category_id' => null,      // integer
28 | 					// 'subcategory_id' => null,   // integer
29 | 					// 'format_id' => null,        // integer
30 | 				) ) );
31 | 
32 | 				if ( $events->have_posts() ) :
33 | 					while ( $events->have_posts() ) : $events->the_post(); ?>
34 | 
35 | 						<article id="event-<?php the_ID(); ?>" <?php post_class(); ?>>
36 | 							<header class="entry-header">
37 | 								<?php the_post_thumbnail(); ?>
38 | 
39 | 								<?php the_title( sprintf( '<h1 class="entry-title"><a href="%s" rel="bookmark">', esc_url( get_permalink() ) ), '</a></h1>' ); ?>
40 | 
41 | 								<div class="entry-meta">
42 | 									<?php eventbrite_event_meta(); ?>
43 | 								</div><!-- .entry-meta -->
44 | 							</header><!-- .entry-header -->
45 | 
46 | 							<div class="entry-content">
47 | 								<?php eventbrite_ticket_form_widget(); ?>
48 | 							</div><!-- .entry-content -->
49 | 
50 | 							<footer class="entry-footer">
51 | 								<?php eventbrite_edit_post_link( __( 'Edit', 'eventbrite_api' ), '<span class="edit-link">', '</span>' ); ?>
52 | 							</footer><!-- .entry-footer -->
53 | 						</article><!-- #post-## -->
54 | 
55 | 					<?php endwhile;
56 | 
57 | 					// Previous/next post navigation.
58 | 					eventbrite_paging_nav( $events );
59 | 
60 | 				else :
61 | 					// If no content, include the "No posts found" template.
62 | 					get_template_part( 'content', 'none' );
63 | 
64 | 				endif;
65 | 
66 | 				// Return $post to its rightful owner.
67 | 				wp_reset_postdata();
68 | 			?>
69 | 
70 | 		</main><!-- #main -->
71 | 	</div><!-- #primary -->
72 | 
73 | <?php get_sidebar(); ?>
74 | <?php get_footer(); ?>
75 | 


--------------------------------------------------------------------------------
/tmpl/eventbrite-single.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * The Template for displaying all single Eventbrite events.
 4 |  */
 5 | 
 6 | get_header(); ?>
 7 | 
 8 | 	<div id="primary" class="content-area">
 9 | 		<main id="main" class="site-main" role="main">
10 | 			<?php
11 | 				// Get our event based on the ID passed by query variable.
12 | 				$event = new Eventbrite_Query( array( 'p' => get_query_var( 'eventbrite_id' ) ) );
13 | 
14 | 				if ( $event->have_posts() ) :
15 | 					while ( $event->have_posts() ) : $event->the_post(); ?>
16 | 
17 | 						<article id="event-<?php the_ID(); ?>" <?php post_class(); ?>>
18 | 							<header class="entry-header">
19 | 								<?php the_post_thumbnail(); ?>
20 | 
21 | 								<h1 class="entry-title"><?php the_title(); ?></h1>
22 | 
23 | 								<div class="entry-meta">
24 | 									<?php eventbrite_event_meta(); ?>
25 | 								</div><!-- .entry-meta -->
26 | 							</header><!-- .entry-header -->
27 | 
28 | 							<div class="entry-content">
29 | 								<?php the_content(); ?>
30 | 
31 | 								<?php eventbrite_ticket_form_widget(); ?>
32 | 							</div><!-- .entry-content -->
33 | 
34 | 							<footer class="entry-footer">
35 | 								<?php eventbrite_edit_post_link( __( 'Edit', 'eventbrite_api' ), '<span class="edit-link">', '</span>' ); ?>
36 | 							</footer><!-- .entry-footer -->
37 | 						</article><!-- #post-## -->
38 | 
39 | 					<?php endwhile;
40 | 
41 | 				else :
42 | 					// If no content, include the "No posts found" template.
43 | 					get_template_part( 'content', 'none' );
44 | 
45 | 				endif;
46 | 
47 | 				// Return $post to its rightful owner.
48 | 				wp_reset_postdata();
49 | 			?>
50 | 		</main><!-- #main -->
51 | 	</div><!-- #primary -->
52 | 
53 | <?php get_sidebar(); ?>
54 | <?php get_footer(); ?>
55 | 


--------------------------------------------------------------------------------
/uninstall.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | /**
 3 |  * Tasks to execute on uninstall.
 4 |  *
 5 |  * @package Eventbrite_API
 6 |  */
 7 | 
 8 | /**
 9 |  * First verify that this file is not just being called directly.
10 |  */
11 | if ( !defined( 'WP_UNINSTALL_PLUGIN' ) ) {
12 | 	exit();
13 | }
14 | 
15 | /**
16 |  * Remove all transients.
17 |  */
18 | $transients = get_option( 'eventbrite_api_transients', array() );
19 | if ( $transients ) {
20 | 	foreach ( $transients as $transient ) {
21 | 		delete_transient( $transient );
22 | 	}
23 | }
24 | 
25 | /**
26 |  * Delete plugin options.
27 |  */
28 | delete_option( 'eventbrite_api_transients' );
29 | delete_option( 'eventbrite_api_token' );
30 | 


--------------------------------------------------------------------------------