Club Drupal

- The Feeds module is optional. It's needed only if you you wish to import iCal

  feeds from other sites.

Or, if you have drush, you can install iCalcreator by running this command from

your site's root directory:

    as the event date for the iCal feed. Make sure that you choose a field that

    is a part of every entity that your View displays. Otherwise, the entities

    which don't have that field will be left out of the iCal feed.

    Location property of events in your iCal feed. This field can be a text

    field, a Node Reference field, an Addressfield, or a Location field.

10. Give the Feed a path like 'calendar/%/export.ics', including a '/%/' for

timezone names to real timezone IDs, is from Version24 of the Unicode CLDR:

http://cldr.unicode.org/.

 * hook exists to allow users to alter the original HTML to ensure that it

 * gets converted into pretty plaintext.

 *

 *

 * @param array $text_fields

 *   A reference to an associative array with the following keys and values:

      $event['comment'] = check_plain($comment['value']);

    }

  }

  // Example: Retrieving information from additional fields in the View (using

  // the Fields plugin).

  $event['comment'] = $view->style_plugin->get_field($context['row_index'], 'field_comment');

; Includes for iCal feed import using Feeds

files[] = includes/DateiCalFeedsParser.inc

core = "7.x"

project = "date_ical"

 */

function date_ical_requirements($phase) {

  $requirements = array();

  // Ensure translations don't break at install time.

  $t = get_t();

  if ($phase == 'runtime') {

    if (!function_exists('libraries_detect')) {

      $requirements['date_ical'] = array(

      // Return immediately, since we can't even attempt to determine if iCalcreator is installed.

      return $requirements;

    }

    $library = libraries_detect('iCalcreator');

    if ($library && !empty($library['installed'])) {

      $requirements['date_ical'] = array(

      );

    }

  }

  return $requirements;

}

  // Drupal attempts to instantiate the old feeds plugin classes.

  registry_rebuild();

  cache_clear_all('plugins:feeds:plugins', 'cache');

  // Update all the importers which used DateIcalIcalcreatorParser to use

  // DateiCalFeedsParser instead.

  $importer_data = ctools_export_load_object('feeds_importer', 'all');

    $importer = feeds_importer($key);

    $importer_config = $importer->getConfig();

    $needs_update = ($importer_config['parser']['plugin_key'] == 'DateIcalIcalcreatorParser');

    $processor = $importer->processor;

    $processor_config = $processor->getconfig();

    // Also update importers which use the new parser, but have un-capitalized

        && !empty($processor_config['mappings'][0]['source'])) {

      $needs_update = (strtoupper($processor_config['mappings'][0]['source']) != $processor_config['mappings'][0]['source']);

    }

    if ($needs_update) {

      $importer->setPlugin('DateiCalFeedsParser');

      // Source keys are now capitalized, so we need to update the mappings.

      foreach ($processor_config['mappings'] as &$mapping) {

        $mapping['source'] = strtoupper($mapping['source']);

      }

      $processor->setConfig($processor_config);

      $importer->save();

      // When this importer object got created, a warning was issued about its

      // parser plugin being missing. We corrected that warning above, so we

      // should clear it out to avoid potential confusion.

api = 2

libraries[iCalcreator][download][type] = "get"

libraries[iCalcreator][directory_name] = "iCalcreator"

libraries[iCalcreator][destination] = "libraries"

 * The version number of the current release. This is inserted into the PRODID

 * value of the iCal feeds created by Date iCal, for debugging purposes.

 */

/**

 * Exception class for generic exceptions thrown by this module.

    $variables['page'] = TRUE;

    $variables['title_prefix'] = '';

    $variables['title_suffix'] = '';

    // We don't want to see the author information in our feed.

    $variables['display_submitted'] = FALSE;

    // Comments and links don't belong in an iCal feed.

    if (isset($variables['content']['comments'])) {

      unset($variables['content']['comments']);

    'name' => 'iCalcreator',

    'vendor url' => 'http://github.com/iCalcreator/iCalcreator',

    'download url' => 'http://github.com/iCalcreator/iCalcreator',

    ),

  );

  return $libraries;

}

  // HTML tags may get converted to < and such by the View code, so we need

  // to convert them back to HTML so we can remove them with strip_tags().

  $text = decode_entities($text);

  // Convert <p> tags to double newlines.

  $text = trim(preg_replace("/<p.*?>/i", "\n\n", $text));

  // Separate heading tags from the text around them in both directions.

  $text = trim(preg_replace("/<\\?h\d.*?>/i", "\n\n", $text));

  // Add a newline for each <div>.

  $text = trim(preg_replace("/<div.*?>/i", "\n", $text));

  // Strip the remaining HTML.

  $text = strip_tags($text);

  // Remove newlines added at the beginning.

    array('RRULE', 'RDATE', 'EXRULE', 'EXDATE'),

    explode('|', $repeat_rule)

  );

  module_load_include('inc', 'date_ical', 'date_ical.utils');

  // This "loop" is really just to make sure we get the right array keys. It

  // souldn't ever execute more than once.

function date_ical_get_location_fields($base = 'node', $reset = FALSE) {

  static $fields = array();

  $empty = array('name' => array(), 'alias' => array());

  if (empty($fields[$base]) || $reset) {

    $cid = 'date_ical_location_fields_' . $base;

    if (!$reset && $cached = cache_get($cid, 'cache_views')) {

  if (empty($base)) {

    $base = 'node';

  }

  $cid = 'date_ical_location_fields_' . $base;

  cache_clear_all($cid, 'cache_views');

  // Iterate over all the fields that Views knows about.

  $all_fields = date_views_views_fetch_fields($base, 'field');

  $fields = array();

    $tmp = explode('.', $name);

    $field_name = $tmp[1];

    $table_name = $tmp[0];

    // Skip unsupported field types and fields that weren't defined through

    // the Field module.

    $info = field_info_field($field_name);

    if (!$info || !in_array($info['type'], $supported_location_fields)) {

      continue;

    }

    // Build an array of the field info that we'll need.

    $alias = str_replace('.', '_', $alias);

    $fields['name'][$name] = array(

      'field_name' => $field_name,

      'type' => $info['type'],

    );

    // These are here only to make this $field array conform to the same format

    // as the one returned by _date_views_fields(). They're probably not needed,

    // but I thought that consistency would be a good idea.

    $fields['name'][$name]['real_field_name'] = $field_name;

    $fields['alias'][$alias] = $fields['name'][$name];

  }

  cache_set($cid, $fields, 'cache_views');

  return $fields;

}

  }

  return $new_rrule;

}

function _date_ical_get_repeat_dates($field_name, $repeat_data, $item, $source) {

  module_load_include('inc', 'date_api', 'date_api_ical');

  $field_info = field_info_field($field_name);

  $rrule_values = _date_ical_parse_repeat_rule($repeat_data['RRULE']);

  //$exrule_values = _date_ical_parse_repeat_rule($repeat_data['EXRULE']);

  $rdates = _date_ical_parse_repeat_dates($repeat_data['RDATE']);

  $exdates = _date_ical_parse_repeat_dates($repeat_data['EXDATE']);

  // By the time we get here, the start and end dates have been

  // adjusted back to UTC, but we want localtime dates to do

  // things like '+1 Tuesday', so adjust back to localtime.

  }

  $duration = $start->difference($end);

  $start_datetime = date_format($start, DATE_FORMAT_DATETIME);

  if (!empty($rrule_values['UNTIL']['datetime'])) {

    // The spec says that UNTIL must be in UTC, but not all feed creators

    // follow that rule. If the user specified that he wanted to overcome this

      // Change the parsed UNTIL from UTC to $timezone, so that the

      // date_ical_date() won't convert it.

      $rrule_values['UNTIL']['tz'] = $timezone;

      // Convert the unparsed UNTIL to UTC, since the Date code will use it.

      // It may currently have a Z on it, but only because iCalcreator blindly

      // adds one to DATETIME-type UNTILs if it's not there.

    // No UNTIL and no COUNT? This is an illegal RRULE.

    return array();

  }

  // Convert the EXDATE and RDATE values to datetime strings.

  // Even though exdates and rdates can be specified to the second, Date

  // Repeat's code checks them by comparing them to the date value only.

    $date = date_ical_date($rdate, $timezone);

    $additions[] = date_format($date, 'Y-m-d');

  }

  // TODO: EXRULEs.

  $date_repeat_compatible_rrule = "{$repeat_data['RRULE']}\n{$repeat_data['RDATE']}\n{$repeat_data['EXDATE']}";

  $calculated_dates = date_repeat_calc($date_repeat_compatible_rrule, $start_datetime, $final_repeat_datetime, $exceptions, $timezone, $additions);

  $repeat_dates = array();

 */

function _date_ical_parse_repeat_rule($repeat_rule_string) {

  module_load_include('inc', 'date_api', 'date_api_ical');

  $repeat_rule_string = preg_replace('/(R|EX)RULE.*:/', '', $repeat_rule_string);

  $items = array('DATA' => $repeat_rule_string);

  foreach (explode(';', $repeat_rule_string) as $recur_val) {

    if (empty($key) || empty($value)) {

      continue;

    }

    // The following keys never have multiple values.

    if (in_array($key, array('UNTIL', 'FREQ', 'INTERVAL', 'COUNT', 'WKST'))) {

      if ($key == 'UNTIL') {

      // The rest can be multi-value csv strings.

      $value = explode(',', $value);

    }

    $items[$key] = $value;

  }

  return $items;

 */

function _date_ical_parse_repeat_dates($repeat_date_string) {

  module_load_include('inc', 'date_api', 'date_api_ical');

  $properties = explode("\n", str_replace("\r\n", "\n", $repeat_date_string));

  $parsed_dates = array();

  foreach ($properties as $property) {

    $matches = array();

    if (preg_match('/(R|EX)DATE([^:]*):(.*)/', $property, $matches)) {

 */

class DateiCalFeedsParser extends FeedsParser {

  /**

   * Implements FeedsParser::getMappingSources().

   */

  public function getMappingSources() {

    return parent::getMappingSources() + self::getiCalMappingSources();

  }

  /**

   * Implements FeedsParser::parse().

   */

      throw new DateIcalException(t('Unable to load the iCalcreator library. Please ensure that it is properly installed.'));

    }

    $state = $source->state(FEEDS_PARSE);

    // Read the iCal feed into memory.

    $ical_feed_contents = $fetcher_result->getRaw();

    // Parse the feed into an iCalcreator vcalendar object.

    $calendar = new vcalendar();

    if ($calendar->parse($ical_feed_contents) === FALSE) {

      $url = $source->config[$plugin]['source'];

      throw new DateIcalException(t('Parsing the data from %url failed. Please ensure that this URL leads to a valid iCal feed.', array('%url' => $url)));

    }

    // Total hack to get around iCalcreator's mistreatment of UID "0".

    if (empty($calendar->components[0]->uid) || empty($calendar->components[0]->uid['value'])) {

      $calendar->components[0]->uid = array('value' => 'zero', 'params' => NULL);

    }

    // Allow modules to alter the vcalendar object before we interpret it.

    $context = array(

      'source' => $source,

      'fetcher_result' => $fetcher_result,

    );

    drupal_alter('date_ical_import_vcalendar', $calendar, $context);

    // We've got a vcalendar object created from the feed data. Now we need to

    // convert that vcalendar into an array of Feeds-compatible data arrays.

    // ParserVcalendar->parse() does that.

    require_once DRUPAL_ROOT . '/' . drupal_get_path('module', 'date_ical') . '/libraries/ParserVcalendar.inc';

    $parser = new ParserVcalendar($calendar, $source, $fetcher_result, $source->getConfigFor($this));

    // Using the stored progress pointer (or 0 if it's not set),

    // determine which section of the feed to parse, then parse it.

    $offset = isset($state->pointer) ? $state->pointer : 0;

    $limit = $source->importer->getLimit();

    $rows = $parser->parse($offset, $limit);

    // Report progress.

    $state->total = $parser->getTotalComponents();

    // We need to add 1 to the index of the last parsed componenent so that

    // the subsequent batch starts on the first unparsed component.

    $state->pointer = $parser->getLastComponentParsed() + 1;

    $state->progress($state->total, $state->pointer);

    return new FeedsParserResult($rows);

  }

  /**

   * Defines the default configuration settings for an actual import.

   */

      'skip_days' => $this->config['skip_days'],

    );

  }

  /**

   * Defines the default settings shown on the configuration form.

   */

      'skip_days' => NULL,

    );

  }

  /**

   * Builds the configuration form.

   */

    );

    return $form;

  }

  /**

   * Validation handler for configForm.

   */

      $source_config['skip_days'] = NULL;

    }

  }

  /**

   * Creates the list of mapping sources offered by DateiCalFeedsParser.

   */

      'description' => t('The CATEGORIES property. Catagories that describe the event, which can be imported into taxonomy terms.'),

      'date_ical_parse_handler' => 'parseMultivalueProperty',

    );

    // Allow other modules to add custom source fields.

    drupal_alter('date_ical_mapping_sources', $sources);

    return $sources;

  }

}

 */

function date_ical_views_plugins() {

  $includes_path = drupal_get_path('module', 'date_ical') . '/includes';

  $data = array(

    'module' => 'date_ical',

    'style' => array(

      ),

    ),

  );

  return $data;

}

 * A Views plugin which builds an iCal VEVENT from a single node.

 */

class date_ical_plugin_row_ical_entity extends views_plugin_row {

  // Basic properties that let the row style follow relationships.

  protected $base_table = 'node';

  protected $base_field = 'nid';

  // Stores the nodes loaded with pre_render.

  protected $entities = array();

  /**

   * Initialize the row plugin.

   */

    $this->base_table = $view->base_table;

    $this->base_field = $view->base_field;

  }

  /**

   * Set up the options for the row plugin.

   */

    $options['location_field'] = array('default' => array());

    return $options;

  }

  /**

   * Build the form for setting the row plugin's options.

   */

  public function options_form(&$form, &$form_state) {

    parent::options_form($form, $form_state);

    // Build the select dropdown for the Date field that the user wants to use

    // to populate the date properties in VEVENTs.

    $data = date_views_fields($this->base_table);

        <br>To change the iCal view mode, configure it on the 'Manage Display' page for each Content Type.

        Please note that all HTML will be stripped from the output, to comply with iCal standards."),

    );

    // Build the select dropdown for the text/node_reference field that the user

    // wants to use to (optionally) populate the SUMMARY.

    $summary_fields = date_ical_get_summary_fields($this->base_table);

        Choose which text, taxonomy term reference or Node Reference field you would like to be output as the SUMMARY.

        If using a Node Reference, the Title of the referenced node will be used.'),

    );

    // Build the select dropdown for the text/node_reference field that the user

    // wants to use to (optionally) populate the LOCATION.

    $location_fields = date_ical_get_location_fields($this->base_table);

        If using a Node Reference, the Title of the referenced node will be used.'),

    );

  }

  /**

   * Preload the list of entities which will appear in the view.

   *

    foreach ($values as $row) {

      // Use the $id as the key so we create only value per entity.

      $id = $row->{$this->field_alias};

      // Node revisions need special loading.

      if ($this->view->base_table == 'node_revision') {

        $this->entities[$id] = node_load(NULL, $id);

        $ids[$id] = $id;

      }

    }

    $base_tables = date_views_base_tables();

    $this->entity_type = $base_tables[$this->view->base_table];

    if (!empty($ids)) {

      $this->entities = entity_load($this->entity_type, $ids);

    }

    // Get the language for this view.

    $this->language = $this->display->handler->get_option('field_language');

    $substitutions = views_views_query_substitutions($this->view);

      $this->language = $substitutions[$this->language];

    }

  }

  /**

   * Renders the entities returned by the view into event arrays.

   */

    if (!is_numeric($id)) {

      return NULL;

    }

    // Load the specified entity:

    $entity = $this->entities[$id];

    if (empty($entity)) {

      // This can happen when an RRULE is involved.

      return NULL;

    }

    $date_fields = date_views_fields($this->base_table);

    $date_info = $date_fields['name'][$this->options['date_field']];

    $field_name  = str_replace(array('_value', '_value2'), '', $date_info['real_field_name']);

    $delta_field = $date_info['delta_field'];

    $is_field    = $date_info['is_field'];

    // Sometimes the timestamp is actually the revision timestamp.

    if ($this->view->base_table == 'node_revision' && $field_name == 'timestamp') {

      $field_name = 'revision_timestamp';

    }

    if (!isset($entity->$field_name)) {

      // This entity doesn't have the date property that the user configured

      // our view to use. We can't do anything with it.

      return NULL;

    }

    $date_field = $entity->$field_name;

    // Pull the date value from the specified field of the entity.

    $entity->date_id = array();

    $start = NULL;

      global $base_url;

      $domain = preg_replace('#^https?://#', '', $base_url);

      $entity->date_id[] = "calendar.$id.$field_name.$delta@$domain";

      if (!empty($date_field['value'])) {

        $start = new DateObject($date_field['value'], $date_field['timezone_db']);

        if (!empty($date_field['value2'])) {

      $start = new DateObject($date_field, $date_field['timezone_db']);

      $end   = new DateObject($date_field, $date_field['timezone_db']);

    }

    // Set the item date to the proper display timezone.

    $start->setTimezone(new DateTimeZone($date_field['timezone']));

    $end->setTimezone(new DateTimeZone($date_field['timezone']));

    // Check if the start and end dates indicate that this is an All Day event.

    $all_day = date_is_all_day(

      date_format($start, DATE_FORMAT_DATETIME),

      date_format($end, DATE_FORMAT_DATETIME),

      date_granularity_precision($date_info['granularity'])

    );

    if ($all_day) {

      // According to RFC 2445 (clarified in RFC 5545) the DTEND value is

      // non-inclusive. When dealing with All Day values, they're DATEs rather

      // than DATETIMEs, so we need to add a day to conform to RFC.

      $end->modify("+1 day");

    }

    // If the user specified a LOCATION field, pull that data from the entity.

    $location = '';

    if (!empty($this->options['location_field']) && $this->options['location_field'] != 'none') {

      $location_fields = date_ical_get_location_fields($this->base_table);

      $location_info = $location_fields['name'][$this->options['location_field']];

      $location_field_name = $location_info['real_field_name'];

      // Only attempt this is the entity actually has this field.

      $items = field_get_items($this->entity_type, $entity, $location_field_name);

      if ($items) {

        }

        elseif ($location_info['type'] == 'addressfield') {

          $locations = array();

          foreach ($location_field as $key => $loc) {

            if ($loc && !in_array($key, array('first_name', 'last_name'))) {

              $locations[] = $loc;

        }

      }

    }

    // Create the rendered event using the display settings from the

    // iCal view mode.

    $rendered_array = entity_view($this->entity_type, array($entity), 'ical', $this->language, TRUE);

      'language' => $this->language,

    );

    drupal_alter('date_ical_export_html', $data, $this->view, $context);

    $event = array();

    $event['summary'] = date_ical_sanitize_text($data['summary']);

    $event['description'] = date_ical_sanitize_text($data['description']);

    $uri = entity_uri($this->entity_type, $entity);

    $uri['options']['absolute'] = TRUE;

    $event['url'] = url($uri['path'], $uri['options']);

    if ($location) {

      $event['location'] = date_ical_sanitize_text($location);

    }

    // For this event's UID, use either the date_id generated by the Date

    // module, or the event page's URL if the date_id isn't available.

    $event['uid'] = !empty($entity->date_id) ? $entity->date_id[0] : $event['url'];

    // If we are using a repeat rule (and not just multi-day events) we

    // remove the item from the entities list so that its VEVENT won't be

    // re-created.

      $this->entities[$id] = NULL;

    }

    // According to the iCal standard, CREATED and LAST-MODIFIED must be UTC.

    // Fortunately, Drupal stores timestamps in the DB as UTC, so we just need

    // to tell DateObject to treat the timestamp as UTC from the start.

      // If changed is unset, but created is, use that for last-modified.

      $event['last-modified'] = new DateObject($entity->created, 'UTC');

    }

    // Allow other modules to alter the structured event object, before it gets

    // passed to the style plugin to be converted into an iCalcreator vevent.

    drupal_alter('date_ical_export_raw_event', $event, $this->view, $context);

    return $event;

  }

}

 * A Views plugin which builds an iCal VEVENT from a views row with Fields.

 */

class date_ical_plugin_row_ical_fields extends views_plugin_row {

  /**

   * Set up the options for the row plugin.

   */

    $options['additional_settings']['skip_blank_dates'] = array('default' => FALSE);

    return $options;

  }

  /**

   * Build the form for setting the row plugin's options.

   */

    $date_field_labels = $this->get_date_field_candidates($all_field_labels);

    $date_field_label_options = array_merge(array('first_available' => t('First populated Date field')), $date_field_labels);

    $text_field_label_options = array_merge(array('' => t('- None -')), $all_field_labels);

    $form['instructions'] = array(

      // The surrounding <div> ensures that the settings dialog expands.

      '#prefix' => '<div style="font-size: 90%">',

      '#default_value' => $this->options['additional_settings']['skip_blank_dates'],

    );

  }

  /**

   * Set up the environment for the render() function.

   */

    }

    $this->repeated_dates = array();

  }

  /**

   * Returns an Event array row in the query with index: $row->index.

   */

  public function render($row) {

    $date_field_name = $this->options['date_field'];

    // If this view is set to use the first populated date field, check each

    // field in the row to find the first non-NULL Date field.

    if ($date_field_name == 'first_available') {

        }

      }

    }

    // Fetch the event's date information.

    try {

      if ($date_field_name == 'first_available') {

        throw $e;

      }

    }

    // Create the event by starting with the date array from this row.

    $event = $date;

    $entity = $row->_field_data[$this->view->base_field]['entity'];

    $entity_type = $row->_field_data[$this->view->base_field]['entity_type'];

    // Add the CREATED, LAST-MODIFIED, and URL components based on the entity.

    $uri = entity_uri($entity_type, $entity);

    $uri['options']['absolute'] = TRUE;

    $event['url'] = url($uri['path'], $uri['options']);

    // Generate a unique ID for this event by emulating the way the Date module

    // creates a Date ID.

    if (isset($row->{"field_data_{$date_field_name}_delta"})) {

    global $base_url;

    $domain = preg_replace('#^https?://#', '', $base_url);

    $event['uid'] = "calendar.$entity_id.$date_field_name.$date_field_delta@$domain";

    // Because of the way that Date implements repeating dates, we're going to

    // be given a separate view result for each repeat. We only want to

    // render a VEVENT (with an RRULE) for the first instance of that date, so

        return FALSE;

      }

    }

    // Retrieve the rendered text fields.

    $text_fields['summary'] = $this->get_field($row->index, $this->options['title_field']);

    $text_fields['description'] = $this->get_field($row->index, $this->options['description_field']);

    $text_fields['location'] = $this->get_field($row->index, $this->options['location_field']);

    // Allow other modules to alter the rendered text fields before they get

    // sanitized for iCal-compliance. This is most useful for fields of type

    // "Content: Rendered Node", which are likely to have complex HTML.

      'options' => $this->options,

    );

    drupal_alter('date_ical_export_html', $text_fields, $this->view, $context);

    // Sanitize the text fields for iCal compliance, and add them to the event.

    $event['summary'] = date_ical_sanitize_text($text_fields['summary']);

    $event['location'] = date_ical_sanitize_text($text_fields['location']);

    $event['description'] = date_ical_sanitize_text($text_fields['description']);

    // Allow other modules to alter the event object before it gets passed to

    // the style plugin to be converted into an iCal VEVENT.

    drupal_alter('date_ical_export_raw_event', $event, $this->view, $context);

    return $event;

  }

    $rrule = NULL;

    $delta = 0;

    $is_date_field = FALSE;

    // Fetch the date field value.

    $date_field_value = $this->view->style_plugin->get_field_value($row->index, $date_field_name);

    // Handle date fields.

    if (isset($date_field_value[$delta]) && is_array($date_field_value[$delta])) {

      $is_date_field = TRUE;

      $date_field = $date_field_value[$delta];

      $start = new DateObject($date_field['value'], $date_field['timezone_db']);

      if (!empty($date_field['value2'])) {

        $end = new DateObject($date_field['value2'], $date_field['timezone_db']);

      else {

        $end = clone $start;

      }

      if (isset($date_field['rrule'])) {

        $rrule = $date_field['rrule'];

      }

      $title = strip_tags($this->view->style_plugin->get_field($row->index, $this->options['title_field']));

      throw new BlankDateFieldException(t("The row %title has a blank date. An iCal entry cannot be created for it.", array('%title' => $title)));

    }

    // Set the display timezone to whichever tz is stored for this field.

    // If there isn't a stored TZ, use the site default.

    $timezone = isset($date_field['timezone']) ? $date_field['timezone'] : date_default_timezone(FALSE);

    $dtz = new DateTimeZone($timezone);

    $start->setTimezone($dtz);

    $end->setTimezone($dtz);

    $granularity = 'second';

    if ($is_date_field) {

      $granularity_settings = $this->view->field[$date_field_name]->field_info['settings']['granularity'];

      $granularity = date_granularity_precision($granularity_settings);

    }

    // Check if the start and end dates indicate that this is an All Day event.

    $all_day = date_is_all_day(

      date_format($start, DATE_FORMAT_DATETIME),

      date_format($end, DATE_FORMAT_DATETIME),

      $granularity

    );

    if ($all_day) {

      // According to RFC 2445 (clarified in RFC 5545) the DTEND value is

      // non-inclusive. When dealing with All Day values, they are DATEs rather

      // than DATETIMEs, so we need to add a day to conform to RFC.

      $end->modify("+1 day");

    }

    $date = array(

      'start' => $start,

      'end' => $end,

      'all_day' => $all_day,

      'rrule' => $rrule,

    );

    return $date;

  }

    $field_candidates = array();

    // These are Date, Date (ISO format), and Date (Unix timestamp).

    $date_fields = array('datetime', 'date', 'datestamp');

    foreach ($view_fields as $alias => $label) {

      $handler_class = get_class($handlers[$alias]);

      if ($handler_class == 'views_handler_field_date'

 * Defines a Views style plugin that renders iCal feeds.

 */

class date_ical_plugin_style_ical_feed extends views_plugin_style {

  /**

   * Internal helper function.

   */

  protected function _get_option($option_name) {

    return isset($this->options[$option_name]) ? $this->options[$option_name] : '';

  }

  /**

   * Sets up the iCal feed icon on calendar pages.

   */

      $url_options['query'] = $input;

    }

    $url_options['absolute'] = TRUE;

    $url = url($this->view->get_url(NULL, $path), $url_options);

    // If the user didn't disable the option, change the scheme to webcal://

    // so calendar clients can automatically subscribe via the iCal link.

    if (!$this->_get_option('disable_webcal')) {

      $url = str_replace(array('http://', 'https://'), 'webcal://', $url);

    }

    // Render the feed icon and header tag (except during a View Preview).

    if (empty($this->view->live_preview)) {

      $tooltip = t('Add to My Calendar');

      ));

    }

  }

  /**

   * Set up the options for the style plugin.

   */

  public function option_definition() {

    $false_bool = array('default' => FALSE, 'bool' => TRUE);

    $options = parent::option_definition();

    $options['cal_name'] = array('default' => array());

    $options['no_calname'] = $false_bool;

    $options['unescape_punctuation'] = $false_bool;

    return $options;

  }

  /**

   * Build the form for setting the style plugin's options.

   */

        Enable this option to have Date iCal unescape these characters before it exports the iCal feed.'),

    );

  }

  /**

   * Render the event arrays returned by the row plugin into a VCALENDAR.

   */

      }

    }

    unset($this->view->row_index);

    // Try to load the iCalcreator library.

    $library = libraries_load('iCalcreator');

    if (!$library['loaded']) {

      $config = array('unique_id' => 'Date iCal v' . DATE_ICAL_VERSION);

      $vcalendar = new vcalendar($config);

      $vcalendar->setMethod('PUBLISH');

      // Only include the X-WR-CALNAME property if the user didn't enable

      // the "Exclude Calendar Name" option.

      if (!$this->_get_option('no_calname')) {

          $vcalendar->setProperty('X-WR-CALNAME', $cal_name, array('VALUE' => 'TEXT'));

        }

      }

      // Now add the VEVENTs.

      $timezones = array();

      foreach ($events as $event) {

          // When this happens, just skip it.

          continue;

        }

        $vevent = $vcalendar->newComponent('vevent');

        $vevent->setUid($event['uid']);

        $vevent->setSummary($event['summary']);

        // Get the start date as an array.

        $start = $event['start']->toArray();

        $start_timezone = $event['start']->getTimezone()->getName();

        $timezones[$start_timezone] = $start_timezone;

        if ($event['all_day']) {

          // All Day events need to be DATEs, rather than DATE-TIMEs.

          $vevent->setDtstart($start['year'], $start['month'], $start['day'],

            $start_timezone

          );

        }

        // Add the Timezone info to the start date, for use later.

        $start['tz'] = $event['start']->getTimezone();

        // Only add the end date if there is one.

        if (!empty($event['end'])) {

          $end = $event['end']->toArray();

          $end_timezone = $event['end']->getTimezone()->getName();

          $timezones[$end_timezone] = $end_timezone;

          if ($event['all_day']) {

            $vevent->setDtend($end['year'], $end['month'], $end['day'],

              FALSE, FALSE, FALSE, FALSE, array('VALUE' => 'DATE'));

          }

          $end['tz'] = $event['end']->getTimezone();

        }

        // Handle repeating dates from the date_repeat module.

        if (!empty($event['rrule']) && module_exists('date_repeat')) {

          // Split the rrule into an RRULE and any additions and exceptions.

          module_load_include('inc', 'date_api', 'date_api_ical');

          module_load_include('inc', 'date_repeat', 'date_repeat_calc');

          list($rrule, $exceptions, $additions) = date_repeat_split_rrule($event['rrule']);

          // Add the RRULE itself. We need to massage the data a bit, since

          // iCalcreator expects RRULEs to be in a different format than how

          // Date API gives them to us.

          $vevent->setRrule(_date_ical_convert_rrule_for_icalcreator($rrule));

          // Convert any exceptions to EXDATE properties.

          if (!empty($exceptions)) {

            $exdates = array();

            foreach ($exceptions as $exception) {

              $except = date_ical_date($exception, 'UTC');

              $exception_array = $except->toArray();

              $exdates[] = array(

                'year' =>  $exception_array['year'],

              $vevent->setExdate(array($exdate));

            }

          }

          // Convert any additions to RDATE properties.

          if (!empty($additions)) {

            $rdates = array();

            foreach ($additions as $addition) {

              $add = date_ical_date($addition, 'UTC');

              $addition_array = $add->toArray();

              $rdate = array(

                'year' =>  $addition_array['year'],

                'month' => $addition_array['month'],

                'day' =>   $addition_array['day'],

                // If the user's copy of Date has support for time in RDATEs,

                // use that. Otherwise use the time from the start date.

                'tz' =>     $start['tz']->getName(),

              );

              // If an end date was was calculated above, use that too.

              // iCalcreator expects RDATEs that have end dates to be

              // specified as array($start_rdate, $end_rdate).

                  'day' =>   $addition_array['day'],

                  // If the user's copy of Date has support for time in RDATEs,

                  // use that. Otherwise use the time from the end date.

                  'tz' =>     $end['tz']->getName(),

                );

                $rdate = $rdate_with_end;

              }

              $rdates[] = $rdate;

            }

            // Add each addition as a separate RDATE property.

            $created['timezone']

          );

        }

        // Allow other modules to alter the vevent before it's exported.

        drupal_alter('date_ical_export_vevent', $vevent, $this->view, $event);

      }

      // Now add to the calendar all the timezones used by the events.

      foreach ($timezones as $timezone) {

        if (strtoupper($timezone) != 'UTC') {

          iCalUtilityFunctions::createTimezone($vcalendar, $timezone);

        }

      }

      // Allow other modules to alter the vcalendar before it's exported.

      drupal_alter('date_ical_export_vcalendar', $vcalendar, $this->view);

      $output = $vcalendar->createCalendar();

      // iCalcreator escapes all commas and semicolons in string values, as the

      // spec demands. However, some calendar clients are buggy and fail to

        $output = str_replace('\,', ',', $output);

        $output = str_replace('\;', ';', $output);

      }

      // In order to respect the Exclude DTSTAMP option, we unfortunately have

      // to parse out the DTSTAMP properties after they get rendered. Simply

      // using deleteProperty('DTSTAMP') doesn't work, because iCalcreator

        $output = implode("\r\n", $filtered_lines);

      }

    }

    // These steps shouldn't be run during Preview on the View page.

    if (empty($this->view->live_preview)) {

      // Prevent devel module from appending queries to ical export.

      $GLOBALS['devel_shutdown'] = FALSE;

      drupal_add_http_header('Content-Type', 'text/calendar; charset=UTF-8');

      drupal_add_http_header('Cache-Control', 'no-cache, must-revalidate');

      drupal_add_http_header('Expires', 'Sat, 26 Jul 1997 05:00:00 GMT');

      // For sites with Clean URLs disabled, the Display's "path" value ends

      // up only in the query args, meaning the filename won't be set properly

      // when users download the feed. So we need to manually instruct browsers

        drupal_add_http_header('Content-Disposition', "attachment; filename=\"$filename\"");

      }

    }

    // Allow other modules to alter the rendered calendar.

    drupal_alter('date_ical_export_post_render', $output, $this->view);

    return $output;

  }

}

  protected $config;

  protected $timezones = array();

  protected $xtimezone;

  /**

   * The parsed data for the component that's currently being processed.

   *

   * @var array

   */

  protected $parsed_data = array();

  /**

   * Variables used for batch processing.

   */

  protected $totalComponents = 0;

  protected $lastComponentParsed = 0;

  /**

   * This is the list of iCal properties which are allowed to have more than

   * one entry in a single VEVENT. If we ever support parsing more than just

    'EXDATE', 'EXRULE', 'FREEBUSY', 'RDATE', 'RELATED-TO', 'RESOURCES',

    'RRULE', 'REQUEST-STATUS', 'TZNAME', 'X-PROP'

  );

  /**

   * Constructor.

   */

    $this->fetcherResult = $fetcher_result;

    $this->config = $config;

  }

  /**

   * Parses the vcalendar object into an array of event data arrays.

   *

    while ($component = $this->calendar->getComponent('VTIMEZONE')) {

      $this->timezones[] = $component;

    }

    // This context array is used by date_ical_import_component_alter() and

    // date_ical_import_parsed_data_alter().

    $context2 = array(

      'source' => $this->source,

      'fetcher_result' => $this->fetcherResult,

    );

    // Collect each component, so we can batch them properly in the next loop.

    $raw_components = array();

    $types = array('VEVENT', 'VTODO', 'VJOURNAL', 'VFREEBUSY', 'VALARM');

        $raw_components[] = $vcalendar_component;

      }

    }

    // Store this for use by DateiCalFeedsParser's batch processing code.

    $this->totalComponents = count($raw_components);

    // Parse each raw component in the current batch into a Feeds-compatible

    // event data array.

    $events = array();

        if ($handler) {

          $this->parsed_data[$property_key] = $this->$handler($property_key, $raw_component);

        }

        if ($property_key == 'geofield' && !empty($this->parsed_data['geofield'])) {

          // To make our data readable by geofield_feeds_combined_source(), we

          // need to put it into the format output by Simplepie 1.3.

          $this->parsed_data['location_longitude'] = array($this->parsed_data['geofield']['lon']);

        }

      }

      // Allow modules to alter the final parsed data before we send it to the

      // Feeds processor.

      drupal_alter('date_ical_import_post_parse', $this->parsed_data, $context2);

      // Skip this event if it's earlier than the user's specified skip time.

      if (!$this->_skip_current_event()) {

        $events[] = $this->parsed_data;

      // through the full collection of components.

      $this->lastComponentParsed = $ndx;

    }

    return $events;

  }

  /**

   * Getter for the protected totalComponents property.

   */

  public function getTotalComponents() {

    return $this->totalComponents;

  }

  /**

   * Getter for the protected lastComponentParsed property.

   */

  public function getLastComponentParsed() {

    return $this->lastComponentParsed;

  }

  /**

   * Handler that parses GEO fields.

   *

    }

    return $geo;

  }

  /**

   * Handler that parses text fields.

   *

    if (in_array($property_key, $this->multi_entry_properties)) {

      unset($vcalendar_component->propix[$property_key]);

    }

    if ($text === FALSE) {

      if ($property_key != 'SUMMARY') {

        return NULL;