devernote.module

<?php
/**
 * @file
 * Integration with Evernote cloud api.
 *
 * Provides functionality to retrieve notes and create nodes with them.
 *
 * @see https://github.com/evernote/evernote-cloud-sdk-php
 *
 * @author: Adam Kempler <akempler@gmail.com>
 */


/**
 * Set to TRUE if testing the module against sandbox.evernote.com.
 * @var boolean
 */
define('DEVERNOTE_SANDBOX', FALSE);

/**
 * Notes in evernote with this tag will be imported.
 * This can be overridden on the module's settings page.
 * @var string
 */
define('DEVERNOTE_DEFAULT_TAG', 'drupalimport');


/**
 * Implements hook_menu().
 */
function devernote_menu() {

  $items = array();

  $items['admin/config/content/devernote'] = array(
    'title' => 'Devernote settings',
    'description' => 'Configure the Devernote module',
    'page callback' => 'drupal_get_form',
    'page arguments' => array(
      'devernote_settings_form',
    ),
    'access arguments' => array('administer devernote'),
    'file' => 'devernote.admin.inc',
    'type' => MENU_NORMAL_ITEM,
  );

  $items['devernote_import'] = array(
    'title' => 'Import from Evernote',
    'description' => 'Import notes from evernote.',
    'page callback' => 'devernote_import_by_tag',
    'access arguments' => array('import notes'),
    'type' => MENU_NORMAL_ITEM,
  );

  return $items;
}


/**
 * Implements hook_permission().
 */
function devernote_permission() {
  return array(
    'administer devernote' => array(
      'title' => t('Administer the Devernote module'),
    ),
    'import notes' => array(
      'title' => t('Use Devernote to import notes.'),
    ),
  );
}


/**
 * Implements hook_node_delete().
 *
 * Delete the corresponding devernote_notes record if it exists.
 */
function devernote_node_delete($node) {

  db_delete('devernote_notes')->condition('nid', $node->nid)->execute();

  // Reset the updates field otherwise syncstate will say there are no new notes.
  global $user;

  $num_updated = db_update('devernote_user')
  ->fields(array(
      'updates' => 0,
  ))
  ->condition('uid', $user->uid)
  ->execute();
}


/**
 * Provide a form for importing notes from Evernote.
 */
function devernote_import_form($form, &$form_state) {

  global $user;

  $userinfo = $form_state['build_info']['args'][0];

  // $import_tag = isset($userinfo['tag']) ? $userinfo['tag'] : variable_get('devernote_import_tag', DEVERNOTE_DEFAULT_TAG);
  $form['devernote_import_tag'] = array(
    '#type' => 'textfield',
    '#title' => t('Import tag'),
    '#default_value' => variable_get('devernote_import_tag', DEVERNOTE_DEFAULT_TAG),
    '#description' => t('Notes with this tag name will be imported.'),
  );

  $options = array();
  $types = node_type_get_types();
  if (count($types)) {
    foreach ($types as $type) {
      $options[$type->type] = $type->name;
    }
  }

  $form['devernote_import_type'] = array(
    '#type' => 'select',
    '#title' => t('Import as'),
    '#options' => $options,
    '#default_value' => variable_get('devernote_import_type', 'article'),
    '#description' => t('The content type to create from the imported note.'),
  );

  $form['options'] = array(
    '#type' => 'fieldset',
    '#access' => user_access('administer nodes'),
    '#title' => t('Publishing options'),
    '#collapsible' => TRUE,
    '#collapsed' => FALSE,
    '#group' => 'additional_settings',
    '#attributes' => array(
      'class' => array('node-form-options'),
    ),
  );
  $form['options']['status'] = array(
    '#type' => 'checkbox',
    '#title' => t('Published'),
    '#default_value' => variable_get('devernote_nodestatus', 0),
  );
  $form['options']['promote'] = array(
    '#type' => 'checkbox',
    '#title' => t('Promoted to front page'),
    '#default_value' => variable_get('devernote_nodepromoted', 1),
  );
  $form['options']['comments'] = array(
    '#type' => 'checkbox',
    '#title' => t('Allow comments'),
    '#default_value' => variable_get('devernote_nodecomments', 1),
  );

  global $user;
  $formats = filter_formats($user);
  $default_format = variable_get('devernote_inputformat', '');
  if (!$default_format) {
    $default_format = filter_default_format($user);
  }
  $options = array();
  foreach ($formats as $format) {
    $options[$format->format] = $format->name;
  }
  if (count($options)) {
    $form['format']['input_format'] = array(
      '#type' => 'select',
      '#title' => t('Input Format'),
      '#options' => $options,
      '#default_value' => variable_get('devernote_inputformat', $default_format),
      '#description' => t('Select an input format for the imported note.'),
    );
  }

  $isloaded = extension_loaded('libxml');
  if ($isloaded) {
    $form['conversions'] = array(
      '#type' => 'fieldset',
      '#title' => t('Advanced HTML Conversions:'),
      '#collapsible' => TRUE,
      '#collapsed' => FALSE,
      '#group' => 'html_conversions',
      '#attributes' => array(
        'class' => array('node-form-options'),
      ),
    );
    $form['conversions']['div2p'] = array(
      '#type' => 'checkbox',
      '#title' => t('Convert divs to p tags'),
      '#default_value' => variable_get('devernote_div2p', 0),
      '#description' => t('Check this to convert divs to p tags.'),
    );
    $form['conversions']['convertheadings_info'] = array(
      '#markup' => '<strong>Font size to heading tag conversions</strong><br />
                    When you set different font sizes in Evernote, it uses the font-size attribute to style the text.
                    If you prefer to have your html rendered using html H tags instead, you can use the following text area
                    to specify conversions.<br />
                    Unfortunately you will not know what sizes Evernote will assign until you import it at least once.
                    You can then view the source and see what sizes it used. Then delete the node and import again.<br />
                    Enter font sizes followed by a comma with the corresponding html H tag you want it converted to.
                    One per line. For example:<br />
                    14, h4<br />
                    15, h3<br />
                    16, h2<br />
                    17, h2<br />
                    18, h1<br />
                    With the above settings, when the note gets imported any text wrapped with a &lt;div style="font-size: 11px;"&gt; would get wrapped in an h5 tag instead.<br />
                    Leave the field blank to use the note html as is.<br />
                    NOTE: these settings will be ignored if the input format is set to plain text when importing.',
    );
    $form['conversions']['convertheadings'] = array(
      '#type' => 'textarea',
      '#title' => t('H Tag Conversions:'),
      '#default_value' => variable_get('devernote_convertheadings', ''),
      '#description' => t('Convert font sizes to html h tags.'),
    );
  }

  $form['#submit'][] = 'devernote_import_form_submit';

  $form['submit'] = array(
    '#value' => 'Import',
    '#type' => 'submit',
  );
  return $form;
}

/**
 * Submit handler for devernote_import_form().
 */
function devernote_import_form_submit($form, &$form_state) {
  $form_state['rebuild'] = TRUE;
}


/**
 * Menu callback to display a page for importing Evernote notes as nodes.
 *
 * @return string
 *   The html to display.
 *
 * @todo Move output to template.
 */
function devernote_import_by_tag() {

  composer_manager_register_autoloader();
  $Devernote = new Devernote();
  $out = '';

  if (isset($_POST['form_id']) && $_POST['form_id'] == 'devernote_import_form') {

    // Check if there have been any updated or new content since the last check.
    $updates = $Devernote->evernote_syncstate();
    if ($updates) {
      $tag_name = isset($_POST['devernote_import_tag']) ? $_POST['devernote_import_tag'] : DEVERNOTE_DEFAULT_TAG;
      $tag_guid = $Devernote->get_tag_guid($tag_name);
      if ($tag_guid) {

        global $user;
        $node_settings = array();
        $node_settings['node_type'] = $_POST['devernote_import_type'];
        $node_settings['status'] = isset($_POST['status']) ? $_POST['status'] : variable_get('devernote_nodestatus', 0);
        $node_settings['promote'] = isset($_POST['promote']) ? $_POST['promote'] : variable_get('devernote_nodepromoted', 0);
        $comments = isset($_POST['comments']) ? $_POST['comments'] : variable_get('devernote_nodecomments', 0);
        $node_settings['comments'] = $comments === 0 ? 0 : 2;
        // TODO use filter_fallback_format()?
        $node_settings['input_format'] = isset($_POST['input_format']) ? $_POST['input_format'] : filter_default_format($user);

        $conversions = get_conversions();

        $notes = $Devernote->retrieve_tagged_notes($tag_guid, $conversions, $node_settings);

        if (count($notes)) {
          $out .= '<h3>The following notes were imported from Evernote:</h3>';
          $out .= implode('', $notes);
        } else {
          $out = '<h3>There seems to have been an unknown problem importing the notes.</h3>';
        }

      // The supplied tag wasn't found in evernote.
      } else {
        $out = t("No matching tags in Evernote found that match: @tagname", array('@tagname' => $tag_name));
      }
    // Update count in evernote hasn't changed since last check.
    } else {
      $out = t('There are no new notes tagged for import.');
    }
  // Form hasn't been submitted yet.
  } else {

    $out = '<h3>Import Notes</h3>';

    $form = drupal_get_form('devernote_import_form', $Devernote->userinfo);
    $out .= drupal_render($form);
  }

  return $out;
}


/**
 * Used to convert the conversions entered in the
 * 'devernote_import_form' form. It converts them to an array
 * usable by $Devernote->retrieve_tagged_notes().
 *
 * @return array
 */
function get_conversions() {

  $cleanup = array();
  // TODO remove using $_POST from here.
  if (isset($_POST['convertheadings']) && !empty($_POST['convertheadings'])) {
    $mappings = explode(PHP_EOL, $_POST['convertheadings']);
    if (count($mappings)) {
      $htags = array();
      foreach ($mappings as $mapping) {
        $pieces = explode(',', $mapping);
        $htags[trim($pieces[0])] = trim($pieces[1]);
      }
      $cleanup['htags'] = $htags;
    }
  }
  if (isset($_POST['div2p'])) {
    $cleanup['div2p'] = $_POST['div2p'];
  }

  return $cleanup;
}


/**
 * Save a resource (image).
 *
 * @param EDAM\Types\Resource $resource
 *   A Resource object.
 * @param string $notestoreurl
 *   For example: https://sandbox.evernote.com/shard/s1/notestore
 * @param string $auth_token
 *   For example:
 *   S=s1:U=802ed:E=1513e335e74:C=14ae6822eb8:P=185:A=jsmith-9647:V=2:H=94efbf7661da4dda35246ae3e6e228ea
 *
 * @return array
 *   array if successful otherwise FALSE.
 *   - 'filename' of the saved file if successful.
 *   - 'path_original'
 *   - 'path_imagestyle'
 *   - 'extension'
 *   - 'filename_md5'
 */
function _devernote_save_resource($resource, $notestoreurl, $auth_token) {

  $fileinfo = array();

  // TODO this assumes edam_webApiUrlPrefix
  // is the same as the notestoreurl without "notestore".
  $pieces = explode('/', $resource->mime);
  $extension = array_pop($pieces);

  $url = rtrim($notestoreurl, "notestore");
  $url .= 'res/' . $resource->guid . '.' . $extension;

  $dir = variable_get('file_public_path', conf_path() . '/files') . '/devernote';
  file_prepare_directory($dir, FILE_CREATE_DIRECTORY);

  $filename = $resource->attributes->fileName;
  $extensions = array('jpg', 'jpeg', 'gif', 'png');
  $filename = file_munge_filename($filename, implode(' ', $extensions));
  $filepath = $dir . '/' . $filename;

  $g = new GuzzleHttp\Client();
  $request = $g->createRequest('GET', $url);
  $request->setHeader('Cookie', 'auth=' . $auth_token);
  $response = $g->send($request, ['stream' => TRUE]);
  $length = $response->getHeader('Content-Length');
  $size = file_put_contents($filepath, $response->getBody());

  // TODO possibly compare length and size.
  if ($size) {
    $fileinfo['path_original'] = $filepath;
    $fileinfo['filename'] = $filename;
    // The sdk converts jpeg to jpg for the filename.
    $fileinfo['extension'] = ($extension == 'jpeg') ? 'jpg' : $extension;
    // The sdk converts the filename to an md5 hash of the body.
    $fileinfo['filename_md5'] = md5($resource->data->body);

    $imagestyle = variable_get('devernote_imagestyle', 'none');
    // $errors = file_validate_is_image($filepath);
    if (in_array($extension, $extensions) && $imagestyle != 'none') {
      $styledef = image_style_load($imagestyle);
      if (count($styledef)) {
        $upload_uri = "public://devernote/" . $filename;
        $success = image_style_create_derivative(
            $styledef,
            $upload_uri,
            image_style_path($imagestyle, $upload_uri)
        );
        if ($success) {
          $fileinfo['path_imagestyle'] = image_style_url($imagestyle, $upload_uri);
        }
      }
    }

    return $fileinfo;
  }
  return FALSE;
}


/**
 * Load the secret and consumer api keys from the db.
 *
 * @return array
 *   An associative array of the keys with the keys 'secret' and 'consumer'
 */
function devernote_load_keys() {

  global $user;

  $keys = db_select('devernote_user')
  ->fields('devernote_user', array('secret_key', 'consumer_key'))
  ->condition('uid', $user->uid)
  ->execute()
  ->fetchAssoc();

  if (($keys) && ($keys['secret_key'] != '0')) {
    if (module_exists('aes')) {
      $keys['secret_key'] = aes_decrypt($keys['secret_key']);
    }
    elseif (module_exists('encrypt')) {
      $keys['secret_key'] = decrypt($keys['secret_key']);
    }
  }

  return $keys;
}


class Devernote {

  protected $client = NULL;

  /**
   * @var array
   *  An array of authorization information as well as if the data is valid.
   *
   * 'oauth_token' => 'S=s1:U=802ed:E=1513e335e74:C=14ae6822eb8:P=185:A=jsmith-9647:V=2:H=94efbf7661da4dda35246ae3e6e228ea';
   * 'edam_noteStoreUrl' => 'https://sandbox.evernote.com/shard/s1/notestore'
   * 'edam_expires' => '1452742499940'
   * 'updates' => '25' - the count from syncstate
   * 'tag' => 'drupalimport'
   * 'tag_guid' => 'e669c090-d8b2-1323-9eae-56bd31c64'
   * 'valid' => FALSE
   */
  public $userinfo = array();

  /**
   * @var Exception
   * Any exceptions thrown by the evernote api calls.
   */
  protected $exception = NULL;

  public $errors = array();


  function __construct() {

    $this->initialize_userinfo();

    if ($this->userinfo['valid']) {
      $this->client = new \Evernote\Client($this->userinfo['oauth_token'], DEVERNOTE_SANDBOX);
    }
  }


  /**
   * Set userinfo array using either local data or from authorization.
   */
  public function initialize_userinfo() {

    $this->userinfo['valid'] = FALSE;
    $this->userinfo['tag'] = DEVERNOTE_DEFAULT_TAG;
    $this->userinfo['tag_guid'] = 0;
    $this->userinfo['updates'] = 0;

    $userinfo = $this->load_userinfo();
    if ($userinfo) {
      $this->userinfo = array_merge($this->userinfo, $userinfo);
      $this->userinfo['valid'] = $this->validate_userinfo();
      if ($this->userinfo['valid']) {
        // Only need to decrypt if it came from the db.
        $this->userinfo['oauth_token'] = $this->decrypt_token($userinfo['oauth_token']);
      }
    }

    if (!$userinfo || !$this->userinfo['valid']) {
      $success = $this->authorize_user();
      if ($success) {
        $this->save_userinfo();
      }
      else {
        // TODO check if we've already set an error.
        $this->errors[] = t('There was an error authorizing the account');
      }
    }
  }


  /**
   * Retrieve locally saved user/auth data from the database.
   *
   * @return mixed
   *   Arry of results if record exists otherwise FALSE.
   */
  public function load_userinfo() {

    global $user;

    // Using "AS" to convert fields back to the same keys
    // as we would receive in the $oauth_data array from Evernote.
    $sql = "SELECT
            uid,
            oauth_token,
            notestoreurl AS edam_noteStoreUrl,
            expires AS edam_expires,
            updates,
            tag,
            tag_guid
          FROM {devernote_user}
          WHERE uid = :uid";
    $userinfo = db_query($sql, array(':uid' => $user->uid))->fetchAssoc();

    return $userinfo;
  }

  /**
   * Check if there are new or updated notes since the last check.
   *
   * Saves the new syncstate to the database.
   * Getting the syncstate (updateCount) is a much less expensive call
   * than searching the notes for tagged items.
   *
   * This will retrieve a SyncState object and check the updateCount:
   * object \EDAM\NoteStore\SyncState
   *  public 'currentTime' => int 1421181104176
   *  public 'fullSyncBefore' => int 1421087557000
   *  public 'updateCount' => int 20
   *  public 'uploaded' => int 34066
   *
   * @return bool
   *   TRUE if there are new or updated items. Otherwise FALSE.
   *
   * @see https://dev.evernote.com/doc/articles/polling_notification.php
   */
  public function evernote_syncstate() {

    $noteStore = $this->client->getUserNotestore();

    $syncState = $noteStore->getSyncState($this->userinfo['oauth_token']);

    $currentcount = $syncState->updateCount;
    if ($currentcount > $this->userinfo['updates']) {
      // Save the current count to the db.
      $this->update_user_updates($currentcount);

      $this->userinfo['updates'] = $currentcount;

      return TRUE;
    }

    return FALSE;
  }

  /**
   * Update the 'updates' field in devernote_users.
   *
   * This contains the last update count from evernote.
   *
   * @param int $count
   */
  public function update_user_updates($count) {

    global $user;

    $num_updated = db_update('devernote_user')
    ->fields(array(
        'updates' => $count,
    ))
    ->condition('uid', $user->uid)
    ->execute();
  }


  /**
   * Make sure the $userinfo is valid.
   *
   * For example, oauth_token is set and hasn't expired.
   *
   * @return boolean
   *   TRUE if valid, otherwise FALSE.
   */
  public function validate_userinfo() {

    $valid = FALSE;

    if (isset($this->userinfo['oauth_token']) && (strval($this->userinfo['oauth_token']) != '0')) {

      $valid = $this->validate_notestoreurl();
      $valid = $this->validate_token_date();
    }

    return $valid;
  }

  /**
   * Check if DEVERNOTE_SANDBOX is different from edam_noteStoreUrl in the db.
   *
   * In other words, did we start off using the sandbox, grant authorization
   * which was saved to the db, and then change to production. If so,
   * the if statement will be false and we'll assign an empty array to
   * $userinfo so that we are forced to reauthorize.
   *
   * @return boolean
   *   TRUE if valid otherwise FALSE.
   */
  public function validate_notestoreurl() {

    $url = isset($this->userinfo['edam_noteStoreUrl']) ? $this->userinfo['edam_noteStoreUrl'] : '';
    $sandboxurl = strstr($url, 'sandbox') ? TRUE : FALSE;
    if ($sandboxurl === DEVERNOTE_SANDBOX) {
      return TRUE;
    }
    else {
      return FALSE;
    }
  }

  /**
   * Check if the oauth token has expired.
   *
   * By default these are good for one year.
   *
   * @return boolean
   *   TRUE if valid otherwise FALSE (expired).
   */
  public function validate_token_date() {

    $valid = FALSE;

    if ((time() - (60 * 60 * 24)) < $this->userinfo['edam_expires']) {
      $valid = TRUE;
    }

    return $valid;
  }


  /**
   * Get the tag_guid to use for retrieving notes from Evernote.
   *
   * @return mixed
   *   String containing the guid if successful otherwise FALSE.
   */
  public function get_tag_guid($tag_name) {

    if (isset($this->userinfo['tag_guid']) && ($this->userinfo['tag_guid'])) {
      return $this->userinfo['tag_guid'];
    } else {

      $notestore = $this->client->getUserNotestore();
      $tags = $notestore->listTags($this->userinfo['oauth_token']);

      $tag_guid = FALSE;
      if (count($tags)) {
        foreach ($tags as $tag) {
          if ($tag->name == $tag_name) {
            global $user;
            $tag_guid = $tag->guid;

            $num_updated = db_update('devernote_user')
            ->fields(array(
                'tag_guid' => $tag_guid,
            ))
            ->condition('uid', $user->uid)
            ->execute();
          }
        }
      }
      return $tag_guid;
    }
  }


  /**
   * Decrypt the token.
   *
   * @param string $token
   *   The oauth token provided by Evernote.
   */
  public function decrypt_token($token) {

    $enc_method = variable_get('devernote_enc_method', '');
    if (($enc_method) && $enc_method == 'aes') {
      $token = aes_decrypt($token);
    }
    elseif (($enc_method) && $enc_method == 'encrypt') {
      $token = decrypt($token);
    }

    return $token;
  }

  /**
   * Get the encrypted token.
   *
   * @return string $token
   *   The oauth token provided by Evernote, encrypted if possible.
   */
  public function encrypt_token($token) {

    if (module_exists('aes')) {
      $token = aes_encrypt($token);
      variable_set('devernote_enc_method', 'aes');
    }
    elseif (module_exists('encrypt')) {
      $token = encrypt($token);
      variable_set('devernote_enc_method', 'encrypt');
    }
    else {
      variable_set('devernote_enc_method', 'none');
    }

    return $token;
  }


  /**
   * Authorize with Evernote.
   *
   * If successful, $oauth_data will be an array of:
   * 'oauth_token' => string 'S=s1:U=8b7:E=26ab546123s:C=1535fb4e520:P=185:A=jsmith-5428:V=2:H=3bg2ef3deb26cz40b04c597f986cb2r0'
   * 'oauth_token_secret' => string ''
   * 'edam_shard' => string 's1'
   * 'edam_userId' => string '5719'
   * 'edam_expires' => string '1489135604302'
   * 'edam_noteStoreUrl' => string 'https://www.evernote.com/shard/s1/notestore'
   * 'edam_webApiUrlPrefix' => string 'https://www.evernote.com/shard/s1/'
   *
   * @return boolean
   *   TRUE if the user was authorized otherwise FALSE.
   */
  public function authorize_user() {

    $keys = devernote_load_keys();
    if (!$keys) {
      $this->errors[] = 'Missing api keys. Please set them on the devernote settings page.';
      return FALSE;
    }

    $oauth_handler = new \Evernote\Auth\OauthHandler(DEVERNOTE_SANDBOX);

    global $base_url;
    $callback = $base_url . request_uri();

    try {
      // See above for contents of $oauth_data.
      $oauth_data = $oauth_handler->authorize($keys['consumer_key'], $keys['secret_key'], $callback);
      if ($oauth_data) {
        $this->userinfo['oauth_token'] = $oauth_data['oauth_token'];
        $this->userinfo['edam_userId'] = $oauth_data['edam_userId'];
        $this->userinfo['edam_noteStoreUrl'] = $oauth_data['edam_noteStoreUrl'];
        $this->userinfo['edam_expires'] = $oauth_data['edam_expires'];

        return TRUE;
      }
      return FALSE;
    }
    catch (Evernote\Exception\AuthorizationDeniedException $e) {
      // If the user declines the authorization, an exception is thrown.
      $this->exception = $e;
      $this->errors[] = 'Authorization declined.';

      return FALSE;
    }
  }

  /**
   * Retrieve notes based on a supplied tag_guid.
   *
   * Retrieved notes will be processed via process_note().
   * The processed notes will then be saved via save_node() and save_note().
   *
   * @param string $tag_guid
   *   Unique evernote guid fot the tag.
   *
   * @param array $conversions
   *   An associative array of cleanup options. Can contain:
   *   - mappings: array of font size => h tag. For example:
   *     array('11' => 'h4', '12' => 'h3')
   *   - 'div2p' => TRUE
   *     If set to TRUE divs will be converted to p tags.
   *     (Evernote exports each paragraph as a div).
   *
   * @param array $node_settings
   *   Settings to use when saving notes as nodes.
   *   These are provided by the import form and retrieved from the $_POST var.
   *   'status' => 1 - the status to set for the node.
   *   'promote' => 1 - promoted to front page or not.
   *   'comments' => 1 - whether or not to allow comments.
   *   'import_type' => 'article' - Node type to create.
   *   'input_format' => 'full_html' - 'full_html', 'plain_text', etc.
   *
   * @return array
   *   An array of html links linking to the newly created nodes.
   */
  public function retrieve_tagged_notes($tag_guid, $conversions, $node_settings) {

    $notes = array();

    $filter = new \EDAM\NoteStore\NoteFilter();
    $filter->tagGuids  = array($tag_guid);

    $resultSpec = new \EDAM\NoteStore\NotesMetadataResultSpec();
    $notesMetadataList = $this->client->getUserNotestore()->findNotesMetadata($this->userinfo['oauth_token'], $filter, 0, 100, $resultSpec);

    $imported = FALSE;

    if (count($notesMetadataList->notes)) {

      // Load the guids of previously imported notes.
      $guids = $this->load_imported_notes();

      $nodes = array();
      foreach ($notesMetadataList->notes as $noteMetadata) {

        // Only import the node if we haven't already imported it.
        if (!in_array($noteMetadata->guid, $guids)) {
          $imported = TRUE;
          $note = $this->client->getNote($noteMetadata->guid);

          // Apply any selected conversions to the note/html.
          $body = $this->process_note($note, $conversions);

          $node_settings['title'] = $note->getTitle();
          $node_settings['body'] = $body;
          $node_settings['note_guid'] = $note->getGuid();

          $nid = $this->save_node($node_settings);
          $this->save_note($noteMetadata->guid, $nid);

          // TODO move to theme layer.
          $notes[] = '<p>' . l($node_settings['title'], 'node/' . $nid) . '</p>';
        }
      }
    }

    return $notes;
  }


  /**
   * Process an incoming evernote Note so it can be saved as a node.
   *
   * Also processes any embedded images.
   * For additional methods and attributes of a Note object see:
   * /sites/all/libraries/composer/evernote/evernote-cloud-sdk-php/src/Evernote/Model/Note.php
   *
   * @param Note $note
   *   An evernote sdk Note object. See link path above.
   *
   * @param array $conversions
   *   See retrieve_tagged_notes() for details.
   *
   * @return string
   *   An html version of the note, useful for saving as the body of a node.
   */
  public function process_note($note, $conversions) {

    $body = $note->content->toHtml();

    // TODO verify these are images.
    $resources = $note->getResources();
    if (count($resources)) {
      foreach ($resources as $resource) {
        // Retrieve the image from evernote and save it locally.
        $fileinfo = _devernote_save_resource($resource, $this->userinfo['edam_noteStoreUrl'], $this->userinfo['oauth_token']);

        if (($fileinfo) && isset($fileinfo['extension'])) {
          $replace = '/images/' . $fileinfo['filename_md5'] . '.' . $fileinfo['extension'];
          if (isset($fileinfo['path_imagestyle'])) {
            $url = $fileinfo['path_imagestyle'];
          }
          else {
            $path = file_stream_wrapper_get_instance_by_uri('public://')->getDirectoryPath() . DIRECTORY_SEPARATOR . 'devernote' . DIRECTORY_SEPARATOR . $fileinfo['filename'];
            $url = file_create_url($path);
          }
          $body = str_ireplace($replace, $url, $body);
        }
      }
    }

    if (count($conversions)) {
      $body = $this->cleanup_html($body, $conversions);
    }

    return $body;
  }


  /**
   * Saves authorization information to the db.
   */
  public function save_userinfo() {

    global $user;

    // Convert to seconds from milliseconds as provided by Evernote.
    $digits = strlen((string) $this->userinfo['edam_expires']);
    if ($digits == 13) {
      $this->userinfo['edam_expires'] = (int) $this->userinfo['edam_expires'] / 1000;
    }

    $token = $this->encrypt_token($this->userinfo['oauth_token']);
    // The tag_guid will be retrieved and saved during the import process.
    $tag_guid = isset($this->userinfo['tag_guid']) ? $this->userinfo['tag_guid'] : 0;

    db_merge('devernote_user')
    ->key(array('uid' => $user->uid))
    ->fields(array(
        'oauth_token' => $token,
        'notestoreurl' => $this->userinfo['edam_noteStoreUrl'],
        'expires' => (int) $this->userinfo['edam_expires'],
        'updates' => $this->userinfo['updates'],
        'tag' => $this->userinfo['tag'],
        'tag_guid' => $this->userinfo['tag_guid'],
    ))
    ->execute();
  }

  /**
   * Load the guids of all previously imported notes.
   *
   * @return array
   *   Array of note guids. Used to check if a note has already been imported.
   */
  public function load_imported_notes() {
    $guids = db_select('devernote_notes')
    ->fields('devernote_notes', array('note_guid'))
    ->execute()
    ->fetchCol();

    return $guids;
  }


  /**
   * Cleanup html retrieved from Evernote.
   *
   * For example, convert divs to p tags.
   * Also map font size attributes to h tags.
   *
   * @param string $html
   *   The html to cleanup.
   * @param array $cleanup
   *   An associative array of cleanup options. Can contain:
   *   - mappings: array of font size => h tag. For example:
   *     array('11' => 'h4', '12' => 'h3')
   *   - 'div2p' => TRUE
   *     If set to TRUE divs will be converted to p tags.
   *
   * @return string
   *   cleaned up/converted html.
   */
  public function cleanup_html($html, $cleanup) {

    $htags = isset($cleanup['htags']) && count($cleanup['htags']) ? TRUE : FALSE;
    $div2p = isset($cleanup['div2p']) ? TRUE : FALSE;

    // Replace spans containing a font-size with an h tag
    // based on the mappings provided in $cleanup['htags'].
    if ($htags) {
      $dom = new DOMDocument();
      $dom->loadHTML($html);
      $spans = $dom->getElementsByTagName("span");
      $replacements = array();
      for ($i = $spans->length - 1; $i >= 0; $i--) {
        $spannode = $spans->item($i);
        if ($spannode->hasAttribute('style')) {
          $attribute = $spannode->getAttribute('style');
          if (stristr($attribute, 'font-size')) {

            $pattern = '/font-size\s*?:.*?(;|(?=""|\'|;))/';
            preg_match($pattern, $attribute, $match);
            $pieces = explode(':', $match[0]);
            // Trimming for pt and px because both come out of Evernote.
            $size = trim($pieces[1], " pt;");
            $size = trim($size, "px;");

            // Lookup the h tag to use in place of the font-size.
            if (array_key_exists($size, $cleanup['htags'])) {
              $htag = $cleanup['htags'][$size];
              $hnode = $dom->createElement($htag, $spannode->nodeValue);
              $spannode->parentNode->replaceChild($hnode, $spannode);

              // We now create a trail of tags from the  h tag to the parent div
              // So that we can do a str_replace.
              // For example we might have something like: <div><em><h3>
              // (where the h3 replaced a span tag).
              // The goal here is to get rid of the div and em tags now that
              // we have the h3 tag in place of the span.
              $lineage = array();
              $lineage[] = $htag;

              $parent1 = $hnode->parentNode->nodeName;
              $lineage[] = $parent1;
              $index = $htag . $parent1;

              if ($parent1 != 'div') {
                $parent2 = $hnode->parentNode->parentNode->nodeName;
                $index .= $parent2;
                $lineage[] = $parent2;
              }
              $replacements[$index] = $lineage;
            }
          }
        }
      }

      // Now we look for divs with font-size because Evernote is not consistent.
      $divs = $dom->getElementsByTagName("div");
      for ($i = $divs->length - 1; $i >= 0; $i--) {
        $divnode = $divs->item($i);
        if ($divnode->hasAttribute('style')) {
          $attribute = $divnode->getAttribute('style');
          if (stristr($attribute, 'font-size')) {
            $pattern = '/font-size\s*?:.*?(;|(?=""|\'|;))/';
            preg_match($pattern, $attribute, $match);
            $pieces = explode(':', $match[0]);
            // Trimming for pt and px because both come out of Evernote.
            $size = trim($pieces[1], " pt;");
            $size = trim($size, "px;");
            if (array_key_exists($size, $cleanup['htags'])) {
              $htag = $cleanup['htags'][$size];
            }
            else {
              $htag = 'h5';
            }
            $hnode = $dom->createElement($htag, $divnode->nodeValue);
            $divnode->parentNode->replaceChild($hnode, $divnode);
          }
        }
      }

      $html = $dom->saveHTML();

      // Run the replacements defined when converting spans to h3 tags.
      if (count($replacements)) {
        foreach ($replacements as $key => $tags) {
          $begin = '';
          $end = '';
          $htag = $tags[0];
          foreach ($tags as $tag) {
            $end .= '</' . $tag . '>';
          }
          $tags = array_reverse($tags);
          foreach ($tags as $tag) {
            $begin .= '<' . $tag . '>';
          }
          $html = str_replace(array($begin, $end), array('<' . $htag . '>', '</' . $htag . '>'), $html);
        }
      }
    }

    if ($div2p) {
      $html = str_replace('<div>&nbsp;</div>', '', $html);
      $html = str_replace('<div><br clear="none"></div>', '', $html);
      $html = str_replace('<div><br></div>', '', $html);
      $html = str_replace('<div><br/></div>', '', $html);
      $html = str_replace('<div><br /></div>', '', $html);
      $html = str_replace(array('<div>', '</div>'), array('<p>', '</p>'), $html);
      $html = str_replace('<br clear="none">', '', $html);
    }

    return $html;
  }


  /**
   * Save an imported Evernote note as a node.
   *
   * @param array $info
   *   The data to save for the node.
   *   'type' - the type of node to create.
   *   'body' - the node body content to save.
   *   'title' - the title for the node.
   *   'status' - the publishing status. Defaults to 0, unpublished.
   *   'comment' - 0 = comments disabled, 1 = read only (default), 2 = read/write.
   *   'promote' - Promoted to the front page or not. Defaults to 1.
   *   'input_format' - plain_text, filtered_html, full_html, etc.
   *    You can set the defaults for status, comment, format, and promote on the
   *    module's configuration page.
   *
   * @return int
   *   The nid of the saved node.
   */
  public function save_node($info) {

    global $user;

    $node = new stdClass();
    $node->type = $info['node_type'];
    $node->title = $info['title'];
    node_object_prepare($node);

    $node->uid = $user->uid;
    $node->language = LANGUAGE_NONE;

    // $info['body'] = check_markup($info['body'], $info['input_format']);
    $node->body[$node->language][0]['value'] = $info['body'];
    $node->body[$node->language][0]['summary'] = text_summary($info['body']);
    $node->body[$node->language][0]['format']  = $info['input_format'];

    $node->status = $info['status'];
    $node->comment = $info['comments'];
    $node->promote = $info['promote'];

    node_save($node);

    return $node->nid;
  }

  /**
   * Save the devernote_notes record.
   *
   * @param string $note_guid
   *   Unique id of the note: Note->getGuid()
   *
   * @param int $nid
   *   Node nid.
   */
  public function save_note($note_guid, $nid) {

    global $user;

    Database::getConnection('default', 'default')->insert('devernote_notes')
    ->fields(array(
        'note_guid' => $note_guid,
        'nid' => $nid,
        'uid' => $user->uid,
    ))
    ->execute();
  }

}