wsdl_docs.module

<?php

/**
 * @file
 * Provides a UI client for SOAP services.
 */

include_once 'wsdl_docs.inc';

/**
 * Directory for the services files.
 */
define('WSDL_SUBDIR', 'wsdl_docs_files');
define('WSDL_DIRECTORY', 'private://' . WSDL_SUBDIR . '/');

/**
 * Implements hook_preprocess_node().
 */
function wsdl_docs_preprocess_node($vars) {
  if ($vars['type'] == 'operations') {
    drupal_add_css(drupal_get_path('module', 'wsdl_docs') . '/ui/ui.css');
  }
}

/**
 * Implements hook_permission().
 */
function wsdl_docs_permission() {
  return array(
    'use wsdl docs services' => array(
      'title' => t('Make REST requests for WSDL Docs via Services'),
    ),
    'download wsdl xsd files' => array(
      'title' => t('Download WSDL and XSD documents as displayed on operation nodes'),
    )
  );
}

/**
 * Publish our testing UI and ajax callbacks.
 *
 * Implements hook_menu().
 */
function wsdl_docs_menu() {
  // Page for deleting a WSDL service.
  $items['wsdl_docs/%/delete'] = array(
    'page callback' => '_wsdl_docs_service_delete',
    'file' => 'wsdl_docs.inc',
    'delivery callback' => 'drupal_json_output',
    'access callback' => 'wsdl_docs_basic_auth',
    'access arguments' => array(
      'wsdl_docs_service_delete',
      'user_access',
      array('access content'),
    ),
    'type' => MENU_CALLBACK,
  );
  // Display all WSDL services.
  $items['admin/content/wsdl_docs'] = array(
    'title' => 'WSDL Docs',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('wsdl_docs_form'),
    'access arguments' => array('access administration pages'),
    'type' => MENU_NORMAL_ITEM,
    'description' => 'WSDL docs',
    'weight' => -99,
  );
  // Add a WSDL service.
  $items['admin/content/wsdl_docs/add'] = array(
    'title' => 'Add WSDL',
    'page callback' => 'entity_ui_get_form',
    'page arguments' => array('wsclient_service', NULL, 'add'),
    'access callback' => 'entity_access',
    'access arguments' => array('create', 'wsclient_service'),
    'description' => 'Import WSDL files to create docs for your SOAP services',
    'type' => MENU_LOCAL_ACTION,
  );
  return $items;
}

/**
 * Implements hook_services_resources().
 *
 * Provide create, update, and delete operations for WSDL services
 * via REST endpoint thanks to the Services module.
 */
function wsdl_docs_services_resources() {
  return array(
    'wsdl' => array(
      'operations' => array(
        'create' => array(
          'help' => 'Create a WSDL Doc service.',
          'file' => array(
            'type' => 'inc',
            'module' => 'wsdl_docs',
            'name' => 'wsdl_docs'
          ),
          'callback' => '_wsdl_docs_service_create',
          'args' => array(
            array(
              'name' => 'data',
              'type' => 'struct',
              'description' => 'The name of the Service being created',
              'source' => 'data',
              'optional' => TRUE,
            ),
          ),
          'access callback' => 'user_access',
          'access arguments' => array('use wsdl docs services'),
        ),
        'update' => array(
          'help' => 'Update an existing WSDL Doc service from a WSDL resource URL.',
          'file' => array(
            'type' => 'inc',
            'module' => 'wsdl_docs',
            'name' => 'wsdl_docs'
          ),
          'callback' => '_wsdl_docs_service_update',
          'args' => array(
            array(
              'name' => 'id',
              'type' => 'string',
              'description' => 'The name of the service to update',
              'source' => array('path' => '0'),
              'optional' => FALSE,
            ),
            array(
              'name' => 'data',
              'type' => 'struct',
              'description' => 'The WSDL Doc',
              'source' => 'data',
              'optional' => FALSE,
            ),
          ),
          'access callback' => 'user_access',
          'access arguments' => array('use wsdl docs services'),
        ),
        'delete' => array(
          'help' => 'Delete a WSDL Doc',
          'file' => array(
            'type' => 'inc',
            'module' => 'wsdl_docs',
            'name' => 'wsdl_docs'
          ),
          'callback' => '_wsdl_docs_service_delete',
          'args' => array(
            array(
              'name' => 'id',
              'type' => 'string',
              'description' => 'The name of the service to delete',
              'source' => array('path' => '0'),
              'optional' => FALSE,
            ),
          ),
          'access callback' => 'user_access',
          'access arguments' => array('use wsdl docs services'),
        ),
      ),
      'targeted_actions' => array(
        'import' => array(
          'help' => 'Import WSDL file. POST multipart/form-data or URL to WSDL resource',
          'file' => array(
            'type' => 'inc',
            'module' => 'wsdl_docs',
            'name' => 'wsdl_docs',
          ),
          'callback' => '_wsdl_docs_service_import',
          'access callback' => 'user_access',
          'access arguments' => array('use wsdl docs services'),
          'args' => array(
            array(
              'name' => 'name',
              'optional' => FALSE,
              'source' => array('path' => 0),
              'type' => 'string',
              'description' => 'The name of the WSDL Doc on which the WSDL file should be imported',
            ),
            array(
              'name' => 'soap_api_definition[]',
              'optional' => FALSE,
              'source' => 'data',
              'description' => 'The file parameters',
              'type' => 'array',
            ),
          ),
        ),
      ),
    ),
  );
}

/**
 * Update existing WSDL service.
 *
 * @param object $service
 *   wsclient_service entity.
 * @param object $DOMDocument
 * @throws \Exception
 */
function wsdl_docs_update_wsclient_service($service, $DOMDocument = NULL) {
  // Check if file is wsdl/xsd.
  $endpoint = $service->endpoint();
  // Rebuild types and operations in service.
  $endpoint->initializeMetadata(TRUE);
  $service->save();
  // Create or update operations nodes.
  wsdl_docs_update_service_operations($service, $DOMDocument);
  rules_clear_cache();
  $service->clearCache();
}

/**
 * Custom function for removing namespace from method name.
 *
 * @param string $str
 * @return string
 */
function _wsdl_docs_rem_namespace($str) {
  $arr = explode(':', $str, 2);
  return isset($arr[1]) ? $arr[1] : $arr[0];
}

/**
 * Custom function to get_output.
 * Called in step 4 of wsdl_docs_update_service_operations().
 *
 * @param string $operation_name
 *   Name of service operation.
 * @param array $_outputs_messages
 *   List of messages in output tags.
 * @param array $_messages_elements
 *   List of elements in message tags.
 * @param array $_elements_types
 *   List of types in element tags.
 * @param array $_types_properties
 *   List of element properties in data types tags.
 * @return string
 */
function _wsdl_docs_get_output($operation_name, &$_outputs_messages, &$_messages_elements, &$_elements_types, &$_types_properties) {
  $messages = $_outputs_messages[$operation_name];
  // Parse port name.
  $message = $messages[0];
  $part_name = $_messages_elements[$message]['name'];
  $text = '';
  if (isset($_messages_elements[$message]['element'])) {
    $element = $_messages_elements[$message]['element'];
    $element_name = $_elements_types[$element]['name'];
    $element_type = $_elements_types[$element]['type'];
    $properties = $_types_properties[$element_type];
    $text .= $part_name . ' type ' . $element . '<br>';
    $text .= '<ul><li>' . $element_name . ' type ' . $element_type . '<ul>';
    foreach ($properties as $property_name => $property) {
      $text .= '<li>' . $property_name . ' - type ' . $property['type'] . '</li>';
    }
    $text .= '</ul></li></ul>';
  }
  elseif (isset($_messages_elements[$message]['type'])) {
    $type = $_messages_elements[$message]['type'];
    $properties = $_types_properties[$type];
    $text .= $part_name . ' type ' . $type . '<br>';
    $text .= '<ul>';
    foreach ($properties as $property_name => $property) {
      $text .= '<li>' . $property_name . ' - type ' . $property['type'] . '</li>';
    }
    $text .= '</ul>';
  }
  return $text;
}

/**
 * After WSDL service has been updated with a different URL or file describing the SOAP resource,
 * update all of its operation nodes accordingly.
 *
 * @param \WSClientServiceDescription $service
 *   wsclient_service entity.
 * @param DOMDocument $DOMDocument
 * @return string
 *  only returns string if there is an error
 * @throws \Exception
 */
function wsdl_docs_update_service_operations($service, $DOMDocument) {
  global $user;

  if (!$DOMDocument) {
    $wsdl = file_get_contents($service->url);
    $DOMDocument = _wsdl_docs_validate_xml($wsdl);
    if (!$DOMDocument) {
      // XML didn't validate so stop here.
      return 'Invalid XML.';
    }
  }

  $documentations = $styles = $outputs = $outputs_messages = $messages_elements = $elements_types = $types_properties = array();

  $portTypes = $DOMDocument->getElementsByTagName('portType');
  foreach ($portTypes as $portType) {
    $operations = $portType->getElementsByTagName('operation');
    foreach ($operations as $operation) {
      $operation_name = $operation->getAttribute('name');
      // Parse documentation element.
      if (!isset($documentations[$operation_name])) {
        $documentation = $operation->getElementsByTagName('documentation');
        if ($documentation->length > 0) {
          $documentations[$operation_name] = $documentation[0]->nodeValue;
        }
      }
      // For output (step 1): parsing correct output like WSDL viewer is multi step process.
      $message = $operation->getElementsByTagName('output')[0]->getAttribute('message');
      // Remove "tns:" namespace so we can parse the element.
      $message = _wsdl_docs_rem_namespace($message);
      $outputs_messages[$message] = $operation_name;
      $_outputs_messages[$operation_name][] = $message;
    }
  }

  // For output (step 2)
  $messages = $DOMDocument->getElementsByTagName('message');
  foreach ($messages as $message) {
    $message_name = $message->getAttribute('name');
    if (isset($outputs_messages[$message_name])) {
      $part = $message->getElementsByTagName('part')[0];
      $part_name = $part->getAttribute('name');
      if ($part->hasAttribute('element')) {
        $element = $part->getAttribute('element');
        // remove "tns:"
        $element = _wsdl_docs_rem_namespace($element);
        $messages_elements[$element][] = $message_name;
        $_messages_elements[$message_name] = array('name' => $part_name, 'element' => $element);
      }
      elseif ($part->hasAttribute('type')) {
        $type = $part->getAttribute('type');
        // remove "tns:" namespace so we can parse the element.
        $type = _wsdl_docs_rem_namespace($type);
        $messages_elements[$type][] = $message_name;
        $_messages_elements[$message_name] = array('name' => $part_name, 'type' => $type);
      }
    }
  }

  // Parse output (step 3)
  $schemas = $DOMDocument->getElementsByTagName('types')[0]->getElementsByTagName('schema');
  foreach ($schemas as $schema) {
    $elements = $schema->childNodes;
    foreach ($elements as $element) {
      if ($element->localName == 'element') {
        $element_name = $element->getAttribute('name');
        $element2_name = $element_name;
        if (isset($messages_elements[$element_name])) {
          // Parse complexType element.
          if (!$element->hasAttribute('type')) {
            $element = $element->getElementsByTagName('element')[0];
            $element2_name = $element->getAttribute('name');
          }
          if ($element->hasAttribute('type')) {
            $element_type = $element->getAttribute('type');
            // Remove "tns:"
            $element_type = _wsdl_docs_rem_namespace($element_type);
            $elements_types[$element_type][] = $element_name;
            $_elements_types[$element_name] = array('name' => $element2_name, 'type' => $element_type);
          }
        }
      }
    }
  }

  // Parse output output (step 4)
  foreach ($elements_types as $type => $element) {
    $_types_properties[$type] = $service->datatypes[$type]['property info'];
  }
  $operations = $DOMDocument->getElementsByTagName('binding')[0]->childNodes;
  foreach ($operations as $operation) {
    if ($operation->localName == 'operation') {
      $name = $operation->getAttribute('name');
      // Parse style element.
      $operation2 = $operation->getElementsByTagName('operation')[0];
      if ($operation2->hasAttribute('style')) {
        $styles[$name] = $operation2->getAttribute('style');
      }
      // Parse body element.
      $outputs[$name] = _wsdl_docs_get_output($name, $_outputs_messages, $_messages_elements, $_elements_types, $_types_properties);
    }
  }
  // List of new operations.
  $operations = $service->operations;
  // Get old operations for this service.
  $query = db_select('node', 'n');
  $query->innerjoin('field_data_field_service_ref', 'sr', 'sr.entity_id = n.nid');
  $query->fields('n', array('nid', 'title'));
  $query->condition('sr.field_service_ref_target_id', $service->id, '=');
  $result = $query->execute();
  while ($node = $result->fetchAssoc()) {
    // If old operation exists in new operations list.
    if (isset($operations[$node['title']])) {
      // Get new operation data.
      $operation = $operations[$node['title']];
      // Load old operation node.
      $old_node = node_load($node['nid']);
      // Set new documentation, style and output data.
      $old_node->field_documentation['und'][0]['value'] = isset($documentations[$operation['label']]) ? $documentations[$operation['label']] : '';
      $old_node->field_style['und'][0]['value'] = isset($styles[$operation['label']]) ? $styles[$operation['label']] : '';
      $old_node->field_output['und'][0]['value'] = isset($outputs[$operation['label']]) ? $outputs[$operation['label']] : '';
      // Update old operation node
      node_save($old_node);
      // Unset old operation from new operations list.
      unset($operations[$node['title']]);
    }
    // Else if old operation does not exist in new operations list.
    else {
      // Delete old operation node.
      node_delete($node['nid']);
    }
  }
  // New operations left.
  foreach ($operations as $name => $operation) {
    // Create operation node.
    $node = new stdClass();
    // Set operation label as node title.
    $node->title = $operation['label'];
    $node->type = 'operations';
    node_object_prepare($node);
    // Set global user as node user.
    $node->uid = $user->uid;
    $node->status = 1;
    // Set service id as reference on the service.
    $node->field_service_ref['und'][0]['target_id'] = $service->id;
    // Set documentation, style and output data.
    $node->field_documentation['und'][0]['value'] = $documentations[$operation['label']] ?: '';
    $node->field_style['und'][0]['value'] = $styles[$operation['label']] ?: '';
    $node->field_output['und'][0]['value'] = $outputs[$operation['label']] ?: '';
    $node->field_output['und'][0]['format'] = 'full_html';
    // Save new operation node
    $node = node_submit($node);
    node_save($node);
  }
}

/**
 * Implements hook_form_FORM_ID_alter().
 */
function wsdl_docs_form_wsclient_service_form_alter(&$form, &$form_state) {
  // Add the description field after the machine name field.
  $new_form = array();
  foreach ($form as $key => $data) {
    $new_form[$key] = $data;
    if ($key == 'name') {
      $new_form['description'] = [
        '#type' => 'textfield',
        '#title' => t('Description'),
        '#maxlength' => 255,
      ];
      if (!empty($form_state['wsclient_service']->description)) {
        $new_form['description']['#default_value'] = $form_state['wsclient_service']->description;
      }
    }
  }
  $form = $new_form;
  // Determine if this is an existing service being edited.
  // If not, hide some fields to minimize confusion.
  $existing_service = TRUE;
  if (isset($form_state['wsclient_service']->is_new) && $form_state['wsclient_service']->is_new == 1) {
    $existing_service = FALSE;
  }
  if ($existing_service) {
    // Hide the fields.
    $form['operations']['#access'] = FALSE;
    $form['datatypes']['#access'] = FALSE;
    $form['global_parameters']['#access'] = FALSE;
  }
  else {
    // Set soap to default on import drop-down and hide to improve UX/UI experience.
    $form['type']['#default_value'] = 'soap';
    $form['type']['#access'] = FALSE;
  }
  // Replace the wsclient_ui_element_url_validate function.
  $form['url']['#element_validate'][0] = 'wsdl_docs_wsclient_ui_element_url_validate';
  $form['#validate'][] = 'wsdl_docs_wsclient_service_form_validate';
  // Update operations nodes after save service.
  $form['#submit'][] = 'wsdl_docs_wsclient_service_form_submit';
}

/**
 * FAPI callback to validate a URL.
 *
 * @param array $element
 *   Url form element.
 * @param array $form_state
 */
function wsdl_docs_wsclient_ui_element_url_validate($element, &$form_state) {
  // Check to make sure user has entered a URL.
  if (empty($form_state['input']['url'][1])) {
    form_error($element, t('Please enter a URL'));
  }
  // If user entered a URL, make sure it is valid.
  if (empty($form_state['input']['wsdl_file']['fid'])) {
    if (strpos($element['#value'], WSDL_DIRECTORY) === FALSE && !valid_url($element['#value'], TRUE)) {
      form_error($element, t('Please enter a valid URL.'));
    }
  }
}

/**
 * Validation callback to check if the SOAP service URL points to a valid WSDL
 * file.
 */
function wsdl_docs_wsclient_service_form_validate($form, $form_state) {
  if ($form_state['values']['type'] == 'soap') {
    // The url has to point to a valid WSDL file.
    try {
      // If initializing the SOAPClient succeeds we're good, otherwise we catch
      // the exception below and suppress any further warnings.
      // WARNING: if you have the xdebug PHP module enabled this can cause a
      // fatal error on invalid WSDL files (instead of a catchable SoapFault
      // exception).
//       xdebug_disable();
      @$endpoint = new SOAPClient($form_state['values']['url']);
    }
    catch (SoapFault $e) {
      form_set_error('url', t('Error parsing the WSDL file: %message', array('%message' => $e->getMessage())));
    }
  }
}

/**
 * Submit callback for the web service form to populate operations and data
 * types of the new SOAP service.
 */
function wsdl_docs_wsclient_service_form_submit($form, &$form_state) {
  if ($form_state['values']['type'] == 'soap' && ($form_state['op'] == 'add' || $form_state['op'] == 'edit')) {
    $service_id = $form_state['wsclient_service']->id;
    // Load saved service.
    $service = entity_load_single('wsclient_service', $service_id);
    // Create or update operations.
    wsdl_docs_update_wsclient_service($service);
    if (module_exists('pathauto')) {
      // Create path alias for wsdl service.
      $path = drupal_lookup_path('alias', 'soap_apis/' . $service->id);
      if (!$path) {
        global $language;
        watchdog('wsdl_docs', t('Path alias not found for soap_apis. Notice: %notice'), array('%notice' => print_r($service, 1), WATCHDOG_NOTICE));
        module_load_include('inc', 'pathauto');
        pathauto_create_alias('wsdl_docs', 'insert', 'soap_apis/' . $service->id , array('service' => $service), 'wsdl_docs', $language->language);
      }
    }
    // Add redirect to our list.
    if ($form['#action'] == '/admin/content/wsdl_docs/add') {
      $form_state['redirect'] = 'admin/content/wsdl_docs';
    }
  }
}

/**
 * Implements hook_entity_insert().
 */
function wsdl_docs_entity_insert($entity, $type) {
  if ($type == 'wsclient_service') {
    global $user;
    // Save UID for service.
    $entity->uid = $user->uid;
    // Save time created for service.
    $entity->created = time();
  }
}

/**
 * Implements hook_entity_delete().
 */
function wsdl_docs_entity_delete($entity, $type) {
  if ($type == 'wsclient_service') {
    // Delete saved WSDL file.
    file_unmanaged_delete(WSDL_DIRECTORY . $entity->label . '.wsdl');
    // Delete nodes for operations.
    $query = db_select('node', 'n');
    $query->innerjoin('field_data_field_service_ref', 'sr', 'sr.entity_id = n.nid');
    $query->fields('n', array('nid'));
    $query->condition('sr.field_service_ref_target_id', $entity->id, '=');
    $result = $query->execute();
    $nids = array();
    while ($nid = $result->fetchField()) {
      $nids[] = $nid;
    }
    if (!empty($nids)) {
      node_delete_multiple($nids);
    }
  }
}

/**
 * Implements hook_node_view().
 */
function wsdl_docs_node_view($node, $view_mode, $langcode) {
  if ($node->type == 'operations' && $view_mode == 'full') {
    if (isset($node->field_service_ref['und'][0]['entity'])) {
      $service = $node->field_service_ref['und'][0]['entity'];
      $operation = $node->field_service_ref['und'][0]['entity']->operations[$node->title];
      $form = drupal_get_form('wsdl_docs_operation_invoke', $service, $operation);
      $form['transaction']['#attributes']['class'][] = 'element-hidden';
      // Add links to view WSDL.
      $link = '';
      if (substr($service->url, 0, 7) != 'private') {
        $url = 'https://services.w3.org/xslt?xslfile=http://tomi.vanek.sk/xml/wsdl-viewer.xsl&amp;xmlfile=' . $service->url;
        $link = l(t('View WSDL'), $url);
      }
      // If file is saved via file import, need to fix file path
      // so user is able to download the file.
      if (strstr($service->url, WSDL_DIRECTORY)) {
        $raw_wsdl_link = l(t('Download WSDL'), file_create_url($service->url));
      }
      else {
        $raw_wsdl_link = l(t('View raw WSDL XML'), $service->url);
      }
      $node->content['apiform'] = array(
        '#markup' => '<span class="wsdl-viewer">' . $link . '</span><br><span class="wsdl-file">' . $raw_wsdl_link . '</span>' . drupal_render($form),
        '#weight' => 100,
      );
    }
  }
}

/**
 * Implements hook_form().
 * List of services.
 *
 * @param array $form
 * @param array $form_state
 * @return array
 */
function wsdl_docs_form($form, &$form_state) {
  $form = drupal_get_form('wsclient_service_overview_form', 'wsclient_service');
  $h = $form['table']['#header'];
  $form['table']['#header'] = array($h[0], $h[1], 'User', 'Created', $h[2], 'Service URL');
  $form['table']['#header'][4]['colspan'] -= 2;
  foreach ($form['table']['#rows'] as &$row) {
    $service = $row[0]['data']['#url']['options']['entity'];
    $row[0]['data']['#url']['path'] = 'soap_apis/' . $row[0]['data']['#url']['options']['entity']->id;
    if ($service->uid > 0) {
      $username = db_select('users', 'u')
        ->fields('u', array('name'))
        ->condition('u.uid', $service->uid)
        ->execute()
        ->fetchField();
      $username = l($username, 'user/' . $service->uid . '/edit');
    }
    else {
      $username = 'REST import';
    }
    $created = date('l m-d-Y H:i:s', $service->created);

    // Add link to download zip (if available).
    $zip_link = l($service->url, $service->url);
    $ext = pathinfo($service->url, PATHINFO_EXTENSION);
    if (!empty($ext)) {
      // Get length of service url file's extension (could be zip, wsdl, or xsd).
      $ext_length = strlen($ext);
      // Strip those characters from the service url file's name, then append '.zip'.
      $zip_filename = (substr( $service->url, 0, (-1 * $ext_length))) . 'zip';
      // If a zip file exists that matches, add a link to the zip in the admin screen.
      if (file_exists($zip_filename)) {
        $zip_link = l(t('archive of multiple files'), file_create_url($zip_filename));
      }
      else {
        $zip_link = l(t('single file'), file_create_url($service->url));
      }
    }
    $row = array($row[0], $row[1], $username, $created, $row[2], $row[4], $zip_link);
  }

  return $form;
}

/**
 * Implements hook_views_pre_render().
 */
function wsdl_docs_views_pre_render(&$view) {
  if ($view->name == 'operations' && $view->current_display == 'page') {
    $view->build_info['title'] = db_select('wsclient_service', 's')
      ->fields('s', array('label'))
      ->condition('s.id', $view->args[0])
      ->execute()
      ->fetchField();
  }
}

/**
 * Implements hook_token_info().
 */
function wsdl_docs_token_info() {
  $types['wsdl_docs'] = array(
    'name' => t('Wsdl service'),
    'description' => t('Wsdl service.'),
  );
  $wsdl['title'] = array(
    'name' => t('Wsdl service name'),
    'description' => t('Token for service name'),
  );
  return array(
    'types' => $types,
    'tokens' => array(
      'wsdl_docs' => $wsdl
    ),
  );
}

/**
 * Implements hook_tokens().
 */
function wsdl_docs_tokens($type, $tokens, array $data = array(), array $options = array()) {
  $replacements = array();
  $sanitize = !empty($options['sanitize']);
  if ($type == 'wsdl_docs') {
    foreach ($tokens as $name => $original) {
      switch ($name) {
      case 'title':
        $replacements[$original] = $sanitize ? filter_xss($data['service']->label) : $data['service']->label;
        break;
      }
    }
  }
  return $replacements;
}

/**
 * Implements hook_pathauto().
 */
function wsdl_docs_pathauto($op) {
  $settings = new stdClass();
  $settings->module = 'wsdl_docs';
  $settings->groupheader = t('Wsdl service paths');
  $settings->patterndescr = t('Default path pattern');
  $settings->patterndefault = 'soap_apis/[wsdl_docs:title]';
  $settings->token_type = 'wsdl_docs';
  $settings->patternitems = array('wsdl' => 'WSDL Docs');
  $settings->batch_update_callback = 'wsdl_docs_pathauto_bulkupdate';
  return $settings;
}

/**
 * Implements batch_update_callback() required by wsdl_docs_pathauto().
 */
function wsdl_docs_pathauto_bulkupdate() {
  // @todo
}

/**
 * Implements hook_views_pre_view().
 *
 * For the Related APIs block displayed on a given operations node,
 * filter by referenced service.
 */
function wsdl_docs_views_pre_view(&$view, &$display_id, &$args) {
  if (($view->name == 'operations') && ($display_id == 'api_explorer')) {
    // Get referenced service.
    $node = menu_get_object();
    $node_wrapper = entity_metadata_wrapper('node', $node->nid);
    $referenced_service = $node_wrapper->field_service_ref->value();
    // Add service id as a filter to view.
    $filters = $view->display_handler->get_option('filters');
    if (empty($filters['field_service_ref_target_id'])) {
      // Only display operations nodes that reference the same service.
      $view->add_item(
        $display_id,
        'filter',
        'field_data_field_service_ref',
        'field_service_ref_target_id',
        array(
          'operator' => '=',
          'value' => ['value' => $referenced_service->id],
          'group' => 1
        )
      );
    }
    // Add nid as a filter to view.
    if (empty($filters['nid'])) {
      // Don't include current operation in list of related operations.
      $view->add_item(
        $display_id,
        'filter',
        'node',
        'nid',
        array(
          'operator' => '!=',
          'value' => ['value' => $node->nid],
          'group' => 1
        )
      );
    }
  }
}

/**
 * Implements hook_file_download().
 */
function wsdl_docs_file_download($uri) {
  $path_elements = explode('/', $uri);
  if (!in_array(WSDL_SUBDIR, $path_elements)) {
    return NULL;
  }
  if (user_access('download wsdl xsd files')) {
    $file = file_uri_to_object($uri);
    return file_get_content_headers($file);
  }
  else {
    return -1;
  }
}

/**
 * Implements hook_flag_type_info().
 *
 * Makes wsclient_service entities flaggable per contrib Flag module.
 */
function wsdl_docs_flag_type_info() {
  return array(
    'wsclient_service' => array(
      'title' => t('WSDL Service'),
      'description' => t("A WSDL Service that documents a SOAP API via its operations."),
      'handler' => 'flag_entity',
      'module' => 'wsdl_docs',
    ),
  );
}