OrcidProfilePlugin.inc.php

<?php
 
import('lib.pkp.classes.plugins.GenericPlugin');
 
define('ORCID_URL', 'https://orcid.org/');
define('ORCID_URL_SANDBOX', 'https://sandbox.orcid.org/');
define('ORCID_API_URL_PUBLIC', 'https://pub.orcid.org/');
define('ORCID_API_URL_PUBLIC_SANDBOX', 'https://pub.sandbox.orcid.org/');
define('ORCID_API_URL_MEMBER', 'https://api.orcid.org/');
define('ORCID_API_URL_MEMBER_SANDBOX', 'https://api.sandbox.orcid.org/');
define('ORCID_API_VERSION_URL', 'v2.1/');
define('ORCID_API_SCOPE_PUBLIC', '/authenticate');
define('ORCID_API_SCOPE_MEMBER', '/activities/update');
 
define('OAUTH_TOKEN_URL', 'oauth/token');
define('ORCID_EMPLOYMENTS_URL', 'employments');
define('ORCID_PROFILE_URL', 'person');
define('ORCID_EMAIL_URL', 'email');
define('ORCID_WORK_URL', 'work');
 
class OrcidProfilePlugin extends GenericPlugin {
   const PUBID_TO_ORCID_EXT_ID = ["doi" => "doi", "other::urn" => "urn"];
   const USER_GROUP_TO_ORCID_ROLE = ["Author" => "AUTHOR", "Translator" => "CHAIR_OR_TRANSLATOR","Journal manager"=>"AUTHOR"];
 
   private $submissionIdToBePublished;
   private $currentContextId;
 
   function register($category, $path, $mainContextId = null) {
      $success = parent::register($category, $path, $mainContextId);
      if (!Config::getVar('general', 'installed') || defined('RUNNING_UPGRADE')) return true;
      if ($success && $this->getEnabled($mainContextId)) {
         $contextId = ($mainContextId === null) ? $this->getCurrentContextId() : $mainContextId;
 
         // Insert the OrcidHandler to handle ORCID redirects
         HookRegistry::register('LoadHandler', array($this, 'setupCallbackHandler'));
 
         // Register callback for Smarty filters; add CSS
         HookRegistry::register('TemplateManager::display', array($this, 'handleTemplateDisplay'));
 
         // Add "Connect ORCID" button to PublicProfileForm
         HookRegistry::register('User::PublicProfile::AdditionalItems', array($this, 'handleUserPublicProfileDisplay'));
 
         // Display additional ORCID access information and checkbox to send e-mail to authors in the AuthorForm
         HookRegistry::register('authorform::display', array($this, 'handleFormDisplay'));
 
         // Send email to author, if the added checkbox was ticked
         HookRegistry::register('authorform::execute', array($this, 'handleAuthorFormExecute'));
 
         // Handle ORCID on user registration
         HookRegistry::register('registrationform::execute', array($this, 'collectUserOrcidId'));
 
         // Send emails to authors without ORCID id upon submission
         HookRegistry::register('submissionsubmitstep3form::execute', array($this, 'handleSubmissionSubmitStep3FormExecute'));
 
         HookRegistry::register('authordao::getAdditionalFieldNames', array($this, 'handleAdditionalFieldNames'));
 
         // Add more ORCiD fields to UserDAO
         HookRegistry::register('userdao::getAdditionalFieldNames', array($this, 'handleAdditionalFieldNames'));
 
         // Send emails to authors without authorised ORCID access on promoting a submission to copy editing. Not included in OPS.
         if ($this->getSetting($contextId, 'sendMailToAuthorsOnPublication')) {
            HookRegistry::register('EditorAction::recordDecision', array($this, 'handleEditorAction'));
         }
 
         HookRegistry::register('Publication::publish', array($this, 'handlePublicationStatusChange'));
 
         // Add more ORCiD fields to author Schema
         HookRegistry::register('Schema::get::author', function ($hookName, $args) {
            $schema = $args[0];
 
            $schema->properties->orcidSandbox = (object)[
               'type' => 'string',
               'apiSummary' => true,
               'validation' => ['nullable']
            ];
            $schema->properties->orcidAccessToken = (object)[
               'type' => 'string',
               'apiSummary' => true,
               'validation' => ['nullable']
            ];
            $schema->properties->orcidAccessScope = (object)[
               'type' => 'string',
               'apiSummary' => true,
               'validation' => ['nullable']
            ];
            $schema->properties->orcidRefreshToken = (object)[
               'type' => 'string',
               'apiSummary' => true,
               'validation' => ['nullable']
            ];
            $schema->properties->orcidAccessExpiresOn = (object)[
               'type' => 'string',
               'apiSummary' => true,
               'validation' => ['nullable']
            ];
            $schema->properties->orcidAccessDenied = (object)[
               'type' => 'string',
               'apiSummary' => true,
               'validation' => ['nullable']
            ];
            $schema->properties->orcidEmailToken = (object)[
               'type' => 'string',
               'apiSummary' => true,
               'validation' => ['nullable']
            ];
            $schema->properties->orcidWorkPutCode = (object)[
               'type' => 'string',
               'apiSummary' => true,
               'validation' => ['nullable']
            ];
         });
      }
 
      return $success;
   }
 
   function getHandlerPath() {
      return $this->getPluginPath() . DIRECTORY_SEPARATOR . 'pages';
   }
 
   function setupCallbackHandler($hookName, $params) {
      $page = $params[0];
      if ($this->getEnabled() && $page == 'orcidapi') {
         $this->import('pages/OrcidHandler');
         define('HANDLER_CLASS', 'OrcidHandler');
         return true;
      }
      return false;
   }
 
   function getSetting($contextId, $name) {
      switch ($name) {
         case 'orcidProfileAPIPath':
            $config_value = Config::getVar('orcid', 'api_url');
            break;
         case 'orcidClientId':
            $config_value = Config::getVar('orcid', 'client_id');
            break;
         case 'orcidClientSecret':
            $config_value = Config::getVar('orcid', 'client_secret');
            break;
         default:
            return parent::getSetting($contextId, $name);
      }
 
      return $config_value ?: parent::getSetting($contextId, $name);
   }
 
   function isGloballyConfigured() {
      $apiUrl = Config::getVar('orcid', 'api_url');
      $clientId = Config::getVar('orcid', 'client_id');
      $clientSecret = Config::getVar('orcid', 'client_secret');
      return isset($apiUrl) && trim($apiUrl) && isset($clientId) && trim($clientId) &&
         isset($clientSecret) && trim($clientSecret);
   }
 
   function handleFormDisplay($hookName, $args) {
      $request = PKPApplication::get()->getRequest();
      $templateMgr = TemplateManager::getManager($request);
      switch ($hookName) {
         case 'authorform::display':
            $authorForm =& $args[0];
            $author = $authorForm->getAuthor();
            if ($author) {
               $authenticated = !empty($author->getData('orcidAccessToken'));
               $templateMgr->assign(
                  array(
                     'orcidAccessToken' => $author->getData('orcidAccessToken'),
                     'orcidAccessScope' => $author->getData('orcidAccessScope'),
                     'orcidAccessExpiresOn' => $author->getData('orcidAccessExpiresOn'),
                     'orcidAccessDenied' => $author->getData('orcidAccessDenied'),
                     'orcidAuthenticated' => $authenticated
                  )
               );
            }
 
            $templateMgr->registerFilter("output", array($this, 'authorFormFilter'));
            break;
      }
      return false;
   }
 
   function handleTemplateDisplay($hookName, $args) {
      $templateMgr =& $args[0];
      $template =& $args[1];
      $request = PKPApplication::get()->getRequest();
 
      // Assign our private stylesheet, for front and back ends.
      $templateMgr->addStyleSheet(
         'orcidProfile',
         $request->getBaseUrl() . '/' . $this->getStyleSheet(),
         array(
            'contexts' => array('frontend', 'backend')
         )
      );
 
      switch ($template) {
         case 'frontend/pages/userRegister.tpl':
            $templateMgr->registerFilter("output", array($this, 'registrationFilter'));
            break;
         case 'frontend/pages/article.tpl':
         case 'frontend/pages/preprint.tpl':
            $script = 'var orcidIconSvg = ' . json_encode($this->getIcon()) . ';';
 
            $publication = $templateMgr->getTemplateVars('publication');
 
            $authors = $publication->getData('authors');
            foreach ($authors as $author) {
               if (!empty($author->getOrcid()) && !empty($author->getData('orcidAccessToken'))) {
                  $script .= '$("a[href=\"' . $author->getOrcid() . '\"]").prepend(orcidIconSvg);';
               }
            }
 
            $templateMgr->addJavaScript('orcidIconDisplay', $script, ['inline' => true]);
 
            break;
      }
      return false;
   }
 
   function getOauthPath() {
      return $this->getOrcidUrl() . 'oauth/';
   }
 
   function getOrcidUrl() {
      $request = Application::get()->getRequest();
      $context = $request->getContext();
      $contextId = ($context == null) ? 0 : $context->getId();
 
      $apiPath = $this->getSetting($contextId, 'orcidProfileAPIPath');
      if ($apiPath == ORCID_API_URL_PUBLIC || $apiPath == ORCID_API_URL_MEMBER) {
         return ORCID_URL;
      } else {
         return ORCID_URL_SANDBOX;
      }
   }
 
   function buildOAuthUrl($handlerMethod, $redirectParams) {
      $request = PKPApplication::get()->getRequest();
      $context = $request->getContext();
      // This should only ever happen within a context, never site-wide.
      assert($context != null);
      $contextId = $context->getId();
 
      if ($this->isMemberApiEnabled($contextId)) {
         $scope = ORCID_API_SCOPE_MEMBER;
      } else {
         $scope = ORCID_API_SCOPE_PUBLIC;
      }
      // We need to construct a page url, but the request is using the component router.
      // Use the Dispatcher to construct the url and set the page router.
      $redirectUrl = $request->getDispatcher()->url($request, ROUTE_PAGE, null, 'orcidapi',
         $handlerMethod, null, $redirectParams);
 
      return $this->getOauthPath() . 'authorize?' . http_build_query(
            array(
               'client_id' => $this->getSetting($contextId, 'orcidClientId'),
               'response_type' => 'code',
               'scope' => $scope,
               'redirect_uri' => $redirectUrl)
         );
   }
 
   function registrationFilter($output, $templateMgr) {
      if (preg_match('/<form[^>]+id="register"[^>]+>/', $output, $matches, PREG_OFFSET_CAPTURE)) {
         $match = $matches[0][0];
         $offset = $matches[0][1];
         $request = Application::get()->getRequest();
         $context = $request->getContext();
         $contextId = ($context == null) ? 0 : $context->getId();
         $targetOp = 'register';
         $templateMgr->assign(array(
            'targetOp' => $targetOp,
            'orcidUrl' => $this->getOrcidUrl(),
            'orcidOAuthUrl' => $this->buildOAuthUrl('orcidAuthorize', array('targetOp' => $targetOp)),
            'orcidIcon' => $this->getIcon(),
         ));
 
         $newOutput = substr($output, 0, $offset + strlen($match));
         $newOutput .= $templateMgr->fetch($this->getTemplateResource('orcidProfile.tpl'));
         $newOutput .= substr($output, $offset + strlen($match));
         $output = $newOutput;
         $templateMgr->unregisterFilter('output', array($this, 'registrationFilter'));
      }
      return $output;
   }
 
   function handleUserPublicProfileDisplay($hookName, $params) {
      $templateMgr =& $params[1];
      $output =& $params[2];
      $request = Application::get()->getRequest();
      $context = $request->getContext();
      $user = $request->getUser();
      $contextId = ($context == null) ? 0 : $context->getId();
      $targetOp = 'profile';
      $templateMgr->assign(
         array(
            'targetOp' => $targetOp,
            'orcidUrl' => $this->getOrcidUrl(),
            'orcidOAuthUrl' => $this->buildOAuthUrl('orcidAuthorize', array('targetOp' => $targetOp)),
            'orcidClientId' => $this->getSetting($contextId, 'orcidClientId'),
            'orcidIcon' => $this->getIcon(),
            'orcidAuthenticated' => !empty($user->getData('orcidAccessToken')),
         )
      );
 
      $output = $templateMgr->fetch($this->getTemplateResource('orcidProfile.tpl'));
      return true;
   }
 
   function authorFormFilter($output, $templateMgr) {
      if (preg_match('/<input[^>]+name="submissionId"[^>]*>/', $output, $matches, PREG_OFFSET_CAPTURE)) {
         $match = $matches[0][0];
         $offset = $matches[0][1];
         $templateMgr->assign('orcidIcon', $this->getIcon());
         $newOutput = substr($output, 0, $offset + strlen($match));
         $newOutput .= $templateMgr->fetch($this->getTemplateResource('authorFormOrcid.tpl'));
         $newOutput .= substr($output, $offset + strlen($match));
         $output = $newOutput;
         $templateMgr->unregisterFilter('output', array($this, 'authorFormFilter'));
      }
      return $output;
   }
 
   function handleAuthorFormExecute($hookname, $args) {
      $form =& $args[0];
      $form->readUserVars(array('requestOrcidAuthorization', 'deleteOrcid'));
 
      $requestAuthorization = $form->getData('requestOrcidAuthorization');
      $deleteOrcid = $form->getData('deleteOrcid');
      $author = $form->getAuthor();
 
      if ($author && $requestAuthorization) {
         $this->sendAuthorMail($author);
      }
 
      if ($author && $deleteOrcid) {
         $author->setOrcid(null);
         $this->removeOrcidAccessToken($author, false);
      }
   }
 
   function collectUserOrcidId($hookName, $params) {
      $form = $params[0];
      $user = $form->user;
 
      $form->readUserVars(array('orcid'));
      $user->setOrcid($form->getData('orcid'));
      return false;
   }
 
   function handleSubmissionSubmitStep3FormExecute($hookName, $params) {
      $form = $params[0];
      // Have to use global Request access because request is not passed to hook
      $publicationDao = DAORegistry::getDAO('PublicationDAO');
      /* @var $publicationDao PublicationDAO */
      $publication = $publicationDao->getById($form->submission->getData('currentPublicationId'));
      $authors = $publication->getData('authors');
 
      $request = Application::get()->getRequest();
      $user = $request->getUser();
      //error_log("OrcidProfilePlugin: authors[0] = " . var_export($authors[0], true));
      //error_log("OrcidProfilePlugin: user = " . var_export($user, true));
      if ($authors[0]->getOrcid() === $user->getOrcid()) {
         // if the author and user share the same ORCID id
         // copy the access token from the user
         //error_log("OrcidProfilePlugin: user->orcidAccessToken = " . $user->getData('orcidAccessToken'));
         $authors[0]->setData('orcidAccessToken', $user->getData('orcidAccessToken'));
         $authors[0]->setData('orcidAccessScope', $user->getData('orcidAccessScope'));
         $authors[0]->setData('orcidRefreshToken', $user->getData('orcidRefreshToken'));
         $authors[0]->setData('orcidAccessExpiresOn', $user->getData('orcidAccessExpiresOn'));
         $authors[0]->setData('orcidSandbox', $user->getData('orcidSandbox'));
 
         $authorDao = DAORegistry::getDAO('AuthorDAO');
         /* @var $authorDao AuthorDAO */
         $authorDao->updateObject($authors[0]);
 
         //error_log("OrcidProfilePlugin: author = " . var_export($authors[0], true));
      }
      return false;
   }
 
   function handleAdditionalFieldNames($hookName, $params) {
      $fields =& $params[1];
      $fields[] = 'orcidSandbox';
      $fields[] = 'orcidAccessToken';
      $fields[] = 'orcidAccessScope';
      $fields[] = 'orcidRefreshToken';
      $fields[] = 'orcidAccessExpiresOn';
      $fields[] = 'orcidAccessDenied';
 
      return false;
   }
 
   function getDisplayName() {
      return __('plugins.generic.orcidProfile.displayName');
   }
 
   function getDescription() {
      return __('plugins.generic.orcidProfile.description');
   }
 
   function getInstallEmailTemplatesFile() {
      return ($this->getPluginPath() . '/emailTemplates.xml');
   }
 
   function smartyPluginUrl($params, $smarty) {
      $path = array($this->getCategory(), $this->getName());
      if (is_array($params['path'])) {
         $params['path'] = array_merge($path, $params['path']);
      } elseif (!empty($params['path'])) {
         $params['path'] = array_merge($path, array($params['path']));
      } else {
         $params['path'] = $path;
      }
 
      if (!empty($params['id'])) {
         $params['path'] = array_merge($params['path'], array($params['id']));
         unset($params['id']);
      }
      return $smarty->smartyUrl($params, $smarty);
   }
 
   function getActions($request, $actionArgs) {
      $router = $request->getRouter();
      import('lib.pkp.classes.linkAction.request.AjaxModal');
      return array_merge(
         $this->getEnabled() ? array(
            new LinkAction(
               'settings',
               new AjaxModal(
                  $router->url(
                     $request,
                     null,
                     null,
                     'manage',
                     null,
                     array(
                        'verb' => 'settings',
                        'plugin' => $this->getName(),
                        'category' => 'generic'
                     )
                  ),
                  $this->getDisplayName()
               ),
               __('manager.plugins.settings'),
               null
            ),
         ) : array(),
         parent::getActions($request, $actionArgs)
      );
   }
 
   function manage($args, $request) {
      switch ($request->getUserVar('verb')) {
         case 'settings':
            $context = $request->getContext();
            $contextId = ($context == null) ? 0 : $context->getId();
 
            $templateMgr = TemplateManager::getManager();
            $templateMgr->registerPlugin('function', 'plugin_url', array($this, 'smartyPluginUrl'));
            $apiOptions = [
               ORCID_API_URL_PUBLIC => 'plugins.generic.orcidProfile.manager.settings.orcidProfileAPIPath.public',
               ORCID_API_URL_PUBLIC_SANDBOX => 'plugins.generic.orcidProfile.manager.settings.orcidProfileAPIPath.publicSandbox',
               ORCID_API_URL_MEMBER => 'plugins.generic.orcidProfile.manager.settings.orcidProfileAPIPath.member',
               ORCID_API_URL_MEMBER_SANDBOX => 'plugins.generic.orcidProfile.manager.settings.orcidProfileAPIPath.memberSandbox'
            ];
            $templateMgr->assign('orcidApiUrls', $apiOptions);
            $templateMgr->assign('logLevelOptions', [
               'ERROR' => 'plugins.generic.orcidProfile.manager.settings.logLevel.error',
               'ALL' => 'plugins.generic.orcidProfile.manager.settings.logLevel.all'
            ]);
            $this->import('OrcidProfileSettingsForm');
            $form = new OrcidProfileSettingsForm($this, $contextId);
            if ($request->getUserVar('save')) {
               $form->readInputData();
               if ($form->validate()) {
                  $form->execute();
                  return new JSONMessage(true);
               }
            } else {
               $form->initData();
            }
            return new JSONMessage(true, $form->fetch($request));
      }
      return parent::manage($args, $request);
   }
 
   function getStyleSheet() {
      return $this->getPluginPath() . '/css/orcidProfile.css';
   }
 
   function getIcon() {
      $path = Core::getBaseDir() . '/' . $this->getPluginPath() . '/templates/images/orcid.svg';
      return file_exists($path) ? file_get_contents($path) : '';
   }
 
   function getMailTemplate($emailKey, $context = null) {
      import('lib.pkp.classes.mail.MailTemplate');
      return new MailTemplate($emailKey, null, $context, false);
   }
 
   public function sendAuthorMail($author, $updateAuthor = false) {
      $request = PKPApplication::get()->getRequest();
      $context = $request->getContext();
 
      // This should only ever happen within a context, never site-wide.
      assert($context != null);
 
      $contextId = $context->getId();
 
      if ($this->isMemberApiEnabled($contextId)) {
         $mailTemplate = 'ORCID_REQUEST_AUTHOR_AUTHORIZATION';
      } else {
         $mailTemplate = 'ORCID_COLLECT_AUTHOR_ID';
      }
 
      $mail = $this->getMailTemplate($mailTemplate, $context);
      $emailToken = md5(microtime() . $author->getEmail());
 
      $author->setData('orcidEmailToken', $emailToken);
 
      $publicationDao = DAORegistry::getDAO('PublicationDAO');
      $publication = $publicationDao->getById($author->getData('publicationId'));
 
      $oauthUrl = $this->buildOAuthUrl('orcidVerify', array('token' => $emailToken, 'publicationId' => $publication->getId()));
      $aboutUrl = $request->getDispatcher()->url($request, ROUTE_PAGE, null, 'orcidapi', 'about', null);
 
      // Set From to primary journal contact
      $mail->setFrom($context->getData('contactEmail'), $context->getData('contactName'));
 
      // Send to author
      $mail->setRecipients(array(array('name' => $author->getFullName(), 'email' => $author->getEmail())));
 
      // Send the mail with parameters
      $mail->sendWithParams(array(
         'orcidAboutUrl' => $aboutUrl,
         'authorOrcidUrl' => $oauthUrl,
         'authorName' => $author->getFullName(),
         'articleTitle' => $publication->getLocalizedTitle(), // Backwards compatibility only
         'submissionTitle' => $publication->getLocalizedTitle(),
      ));
 
      if ($updateAuthor) {
         $authorDao = DAORegistry::getDAO('AuthorDAO');
         $authorDao->updateObject($author);
      }
   }
 
   public function handlePublicationStatusChange($hookName, $args) {
      $newPublication =& $args[0];
      $publication =& $args[1];
      $submission =& $args[2];
      $request = PKPApplication::get()->getRequest();
 
      switch ($newPublication->getData('status')) {
         case STATUS_PUBLISHED:
         case STATUS_SCHEDULED:
            $this->sendSubmissionToOrcid($newPublication, $request);
            break;
      }
   }
 
   public function handleEditorAction($hookName, $args) {
      $submission = $args[0];
      $decision = $args[1];
 
      if ($decision['decision'] == SUBMISSION_EDITOR_DECISION_ACCEPT) {
         $publication = $submission->getCurrentPublication();
 
         if (isset($publication)) {
            $authorDao = DAORegistry::getDAO('AuthorDAO');
            $authors = $authorDao->getByPublicationId($submission->getCurrentPublication()->getId());
 
            foreach ($authors as $author) {
               $orcidAccessExpiresOn = Carbon\Carbon::parse($author->getData('orcidAccessExpiresOn'));
               if ($author->getData('orcidAccessToken') == null || $orcidAccessExpiresOn->isPast()) {
                  $this->sendAuthorMail($author, true);
               }
            }
         }
 
      }
   }
 
   public function sendSubmissionToOrcid($publication, $request) {
      $context = $request->getContext();
      $contextId = $this->currentContextId = $context->getId();
      $publicationId = $publication->getId();
      $submissionId = $publication->getData('submissionId');
 
      if (!$this->isMemberApiEnabled($contextId)) {
         // Sending to ORCID only works with the member API
         return false;
      }
 
      $issueId = $publication->getData('issueId');
      if (isset($issueId)) {
         $issue = Services::get('issue')->get($issueId);
      }
 
      $authorDao = DAORegistry::getDAO('AuthorDAO');
      $authors = $authorDao->getByPublicationId($publicationId);
 
      // Collect valid ORCID ids and access tokens from submission contributors
      $authorsWithOrcid = [];
      foreach ($authors as $author) {
         if ($author->getOrcid() && $author->getData('orcidAccessToken')) {
            $orcidAccessExpiresOn = Carbon\Carbon::parse($author->getData('orcidAccessExpiresOn'));
            if ($orcidAccessExpiresOn->isFuture()) {
               # Extract only the ORCID from the stored ORCID uri
               $orcid = basename(parse_url($author->getOrcid(), PHP_URL_PATH));
               $authorsWithOrcid[$orcid] = $author;
            } else {
               $this->logError("Token expired on $orcidAccessExpiresOn for author " . $author->getId() . ", deleting orcidAccessToken!");
               $this->removeOrcidAccessToken($author);
            }
         }
      }
 
      if (empty($authorsWithOrcid)) {
         $this->logInfo('No contributor with ORICD id or valid access token for submission ' . $submissionId);
         return false;
      }
 
      $orcidWork = $this->buildOrcidWork($publication, $context, $authors, $request, $issue);
      $this::logInfo("Request body (without put-code): " . json_encode($orcidWork));
 
      $requestsSuccess = [];
      foreach ($authorsWithOrcid as $orcid => $author) {
         $url = $this->getSetting($contextId, 'orcidProfileAPIPath') . ORCID_API_VERSION_URL . $orcid . '/' . ORCID_WORK_URL;
         $method = "POST";
 
         if ($putCode = $author->getData('orcidWorkPutCode')) {
            // Submission has already been sent to ORCID. Use PUT to update meta data
            $url .= '/' . $putCode;
            $method = "PUT";
            $orcidWork['put-code'] = $putCode;
         } else {
            // Remove put-code from body because the work has not yet been sent
            unset($orcidWork['put-code']);
         }
 
         $orcidWorkJson = json_encode($orcidWork);
 
         $header = [
            'Content-Type: application/vnd.orcid+json',
            'Content-Length: ' . strlen($orcidWorkJson),
            'Accept: application/json',
            'Authorization: Bearer ' . $author->getData('orcidAccessToken')
         ];
 
         $this->logInfo("$method $url");
         $this->logInfo("Header: " . var_export($header, true));
 
         $ch = curl_init($url);
         curl_setopt_array($ch, [
            CURLOPT_CUSTOMREQUEST => $method,
            CURLOPT_POSTFIELDS => $orcidWorkJson,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => $header
         ]);
         // Use proxy if configured
         if ($httpProxyHost = Config::getVar('proxy', 'http_host')) {
            curl_setopt($ch, CURLOPT_PROXY, $httpProxyHost);
            curl_setopt($ch, CURLOPT_PROXYPORT, Config::getVar('proxy', 'http_port', '80'));
            if ($username = Config::getVar('proxy', 'username')) {
               curl_setopt($ch, CURLOPT_PROXYUSERPWD, $username . ':' . Config::getVar('proxy', 'password'));
            }
         }
 
         $responseHeaders = [];
         // Needed to correctly process response headers.
         // This function is called by curl for each received line of the header.
         // Code from StackOverflow answer here: https://stackoverflow.com/a/41135574/8938233
         // Thanks to StackOverflow user Geoffrey.
         curl_setopt($ch, CURLOPT_HEADERFUNCTION,
            function ($curl, $header) use (&$responseHeaders) {
               $len = strlen($header);
               $header = explode(':', $header, 2);
               if (count($header) < 2) {
                  // ignore invalid headers
                  return $len;
               }
 
               $name = strtolower(trim($header[0]));
               if (!array_key_exists($name, $responseHeaders)) {
                  $responseHeaders[$name] = [trim($header[1])];
               } else {
                  $responseHeaders[$name][] = trim($header[1]);
               }
 
               return $len;
            }
         );
 
         $result = curl_exec($ch);
 
         if (curl_error($ch)) {
            $this->logError('Unable to post to ORCID API, curl error: ' . curl_error($ch));
            curl_close($ch);
            return false;
         }
 
         $httpstatus = curl_getinfo($ch, CURLINFO_HTTP_CODE);
         curl_close($ch);
 
         $this->logInfo("Response status: $httpstatus");
 
         switch ($httpstatus) {
            case 200:
               // Work updated
               $this->logInfo("Work updated in profile, putCode: $putCode");
               $requestsSuccess[$orcid] = true;
               break;
            case 201:
               $location = $responseHeaders['location'][0];
               // Extract the ORCID work put code for updates/deletion.
               $putCode = intval(basename(parse_url($location, PHP_URL_PATH)));
               $this->logInfo("Work added to profile, putCode: $putCode");
               $author->setData('orcidWorkPutCode', $putCode);
               $authorDao->updateObject($author);
               $requestsSuccess[$orcid] = true;
               break;
            case 401:
               // invalid access token, token was revoked
               $error = json_decode($result);
               if ($error->error === 'invalid_token') {
                  $this->logError("$error->error_description, deleting orcidAccessToken from author");
                  $this->removeOrcidAccessToken($author);
               }
               $requestsSuccess[$orcid] = false;
               break;
            case 404:
               // a work has been deleted from a ORCID record. putCode is no longer valid.
               if ($method === 'PUT') {
                  $this->logError("Work deleted from ORCID record, deleting putCode form author");
                  $author->setData('orcidWorkPutCode', null);
                  $authorDao->updateObject($author);
                  $requestsSuccess[$orcid] = false;
               } else {
                  $this->logError("Unexpected status $httpstatus response, body: $result");
                  $requestsSuccess[$orcid] = false;
               }
               break;
            case 409:
               $this->logError('Work already added to profile, response body: ' . $result);
               $requestsSuccess[$orcid] = false;
               break;
            default:
               $this->logError("Unexpected status $httpstatus response, body: $result");
               $requestsSuccess[$orcid] = false;
         }
      }
      if (array_product($requestsSuccess)) {
         return true;
      } else {
         return $requestsSuccess;
      }
   }
 
   public function buildOrcidWork($publication, $context, $authors, $request, $issue = null) {
      $submission = Services::get('submission')->get($publication->getData('submissionId'));
 
      PluginRegistry::loadCategory('generic');
      $citationPlugin = PluginRegistry::getPlugin('generic', 'citationstylelanguageplugin');
      $bibtexCitation = trim(strip_tags($citationPlugin->getCitation($request, $submission, 'bibtex', $issue, $publication)));
 
      $publicationLocale = ($publication->getData('locale')) ? $publication->getData('locale') : 'en_US';
      $supportedSubmissionLocales = $context->getSupportedSubmissionLocales();
 
      $publicationUrl = $request->getDispatcher()->url($request, ROUTE_PAGE, null, 'article', 'view', $submission->getId());
 
      $orcidWork = [
         'title' => [
            'title' => [
               'value' => $publication->getLocalizedData('title', $publicationLocale) ?? ''
            ],
            'subtitle' => [
               'value' => $publication->getLocalizedData('subtitle', $publicationLocale) ?? ''
            ]
         ],
         'journal-title' => [
            'value' => $context->getName($publicationLocale) ?? ''
         ],
         'short-description' => trim(strip_tags($publication->getLocalizedData('abstract', $publicationLocale))) ?? '',
         'type' => 'JOURNAL_ARTICLE',
         'external-ids' => [
            'external-id' => $this->buildOrcidExternalIds($submission, $publication, $context, $issue, $publicationUrl)
         ],
         'publication-date' => $this->buildOrcidPublicationDate($publication, $issue),
         'url' => $publicationUrl,
         'citation' => [
            'citation-type' => 'BIBTEX',
            'citation-value' => $bibtexCitation
         ],
         'language-code' => substr($publicationLocale, 0, 2),
         'contributors' => [
            'contributor' => $this->buildOrcidContributors($authors, $context, $publication)
         ]
      ];
      $translatedTitleAvailable = false;
      foreach ($supportedSubmissionLocales as $defaultLanguage) {
         if ($defaultLanguage !== $publicationLocale) {
            $iso2LanguageCode = substr($defaultLanguage, 0, 2);
            $defaultTitle = $publication->getLocalizedData($iso2LanguageCode);
            if (strlen($defaultTitle) > 0 && !$translatedTitleAvailable) {
               $orcidWork['title']['translated-title'] = ['value' => $defaultTitle, 'language-code' => $iso2LanguageCode];
               $translatedTitleAvailable = true;
            }
         }
      }
 
      return $orcidWork;
   }
 
 
   private function buildOrcidPublicationDate($publication, $issue = null) {
      $publicationPublishDate = Carbon\Carbon::parse($publication->getData('datePublished'));
 
      return [
         'year' => ['value' => $publicationPublishDate->format("Y")],
         'month' => ['value' => $publicationPublishDate->format("m")],
         'day' => ['value' => $publicationPublishDate->format("d")]
      ];
   }
 
   private function buildOrcidExternalIds($submission, $publication, $context, $issue, $articleUrl) {
      $contextId = $context->getId();
 
      $externalIds = array();
      $pubIdPlugins = PluginRegistry::loadCategory('pubIds', true, $contextId);
      // Add doi, urn, etc. for article
      $articleHasStoredPubId = false;
      if (is_array($pubIdPlugins)) {
         foreach ($pubIdPlugins as $plugin) {
            if (!$plugin->getEnabled()) {
               continue;
            }
 
            $pubIdType = $plugin->getPubIdType();
 
            # Add article ids
            $pubId = $publication->getData($pubIdType);
 
            if ($pubId) {
               $externalIds[] = [
                  'external-id-type' => self::PUBID_TO_ORCID_EXT_ID[$pubIdType],
                  'external-id-value' => $pubId,
                  'external-id-url' => [
                     'value' => $plugin->getResolvingURL($contextId, $pubId)
                  ],
                  'external-id-relationship' => 'SELF'
               ];
 
               $articleHasStoredPubId = true;
            }
 
            # Add issue ids if they exist
            $pubId = $issue->getStoredPubId($pubIdType);
            if ($pubId) {
               $externalIds[] = [
                  'external-id-type' => self::PUBID_TO_ORCID_EXT_ID[$pubIdType],
                  'external-id-value' => $pubId,
                  'external-id-url' => [
                     'value' => $plugin->getResolvingURL($contextId, $pubId)
                  ],
                  'external-id-relationship' => 'PART_OF'
               ];
            }
         }
      } else {
         error_log("OrcidProfilePlugin::buildOrcidExternalIds: No pubId plugins could be loaded");
      }
 
      if (!$articleHasStoredPubId) {
         // No pubidplugins available or article does not have any stored pubid
         // Use URL as an external-id
         $externalIds[] = [
            'external-id-type' => 'uri',
            'external-id-value' => $articleUrl,
            'external-id-relationship' => 'SELF'
         ];
      }
 
      // Add journal online ISSN
      // TODO What about print ISSN?
      if ($context->getData('onlineIssn')) {
         $externalIds[] = [
            'external-id-type' => 'issn',
            'external-id-value' => $context->getData('onlineIssn'),
            'external-id-relationship' => 'PART_OF'
         ];
      }
 
      return $externalIds;
   }
 
   private function buildOrcidContributors($authors, $context, $publication) {
      $contributors = [];
      $first = true;
 
      foreach ($authors as $author) {
         // TODO Check if e-mail address should be added
         $fullName = $author->getLocalizedGivenName() . " " . $author->getLocalizedFamilyName();
 
         if (strlen($fullName) == 0) {
            $this->logError("Contributor Name not defined" . $author->getAllData());
         }
         $contributor = [
            'credit-name' => $fullName,
            'contributor-attributes' => [
               'contributor-sequence' => $first ? 'FIRST' : 'ADDITIONAL'
            ]
         ];
 
         $userGroup = $author->getUserGroup();
         $role = self::USER_GROUP_TO_ORCID_ROLE[$userGroup->getName('en_US')];
 
         if ($role) {
            $contributor['contributor-attributes']['contributor-role'] = $role;
         }
 
         if ($author->getOrcid()) {
            $orcid = basename(parse_url($author->getOrcid(), PHP_URL_PATH));
 
            if ($author->getData('orcidSandbox')) {
               $uri = ORCID_URL_SANDBOX . $orcid;
               $host = 'sandbox.orcid.org';
            } else {
               $uri = $author->getOrcid();
               $host = 'orcid.org';
            }
 
            $contributor['contributor-orcid'] = [
               'uri' => $uri,
               'path' => $orcid,
               'host' => $host
            ];
         }
 
         $first = false;
 
         $contributors[] = $contributor;
      }
 
      return $contributors;
   }
 
   public function removeOrcidAccessToken($author, $saveAuthor = true) {
      $author->setData('orcidAccessToken', null);
      $author->setData('orcidAccessScope', null);
      $author->setData('orcidRefreshToken', null);
      $author->setData('orcidAccessExpiresOn', null);
      $author->setData('orcidSandbox', null);
 
      if ($saveAuthor) {
         $authorDao = DAORegistry::getDAO('AuthorDAO');
         $authorDao->updateObject($author);
      }
   }
 
   public static function logFilePath() {
      return Config::getVar('files', 'files_dir') . '/orcid.log';
   }
 
   public function logError($message) {
      self::writeLog($message, 'ERROR');
   }
 
   public function logInfo($message) {
      if ($this->getSetting($this->currentContextId, 'logLevel') === 'ERROR') {
         return;
      } else {
         self::writeLog($message, 'INFO');
      }
   }
 
   private static function writeLog($message, $level) {
      $fineStamp = date('Y-m-d H:i:s') . substr(microtime(), 1, 4);
      error_log("$fineStamp $level $message\n", 3, self::logFilePath());
   }
 
   public function setCurrentContextId($contextId) {
      $this->currentContextId = $contextId;
   }
 
   public function isMemberApiEnabled($contextId) {
      $apiUrl = $this->getSetting($contextId, 'orcidProfileAPIPath');
      if ($apiUrl === ORCID_API_URL_MEMBER || $apiUrl === ORCID_API_URL_MEMBER_SANDBOX) {
         return true;
      } else {
         return false;
      }
   }
}