orcid_client 0.1

data/lib/orcid_client/date.rb

@@ -0,0 +1,61 @@
+module OrcidClient
+  module Date
+    def get_date_parts(iso8601_time)
+      return { "date_parts" => [[]] } if iso8601_time.nil?
+
+      year = iso8601_time[0..3].to_i
+      month = iso8601_time[5..6].to_i
+      day = iso8601_time[8..9].to_i
+      { 'date-parts' => [[year, month, day].reject { |part| part == 0 }] }
+    end
+
+    def get_year_month(iso8601_time)
+      return [nil, nil] if iso8601_time.nil?
+
+      year = iso8601_time[0..3].to_i
+      month = iso8601_time[5..6].to_i
+
+      [year, month]
+    end
+
+    def get_date_parts_from_parts(year = nil, month = nil, day = nil)
+      { 'date-parts' => [[year.to_i, month.to_i, day.to_i].reject { |part| part == 0 }] }
+    end
+
+    def get_parts_from_date_parts(date_parts)
+      parts = date_parts.fetch('date-parts', []).first
+      return { "date_parts" => [[]] } unless parts.present?
+
+      { 'year' => parts[0],
+        'month' => parts[1],
+        'day' => parts[2] }.compact
+    end
+
+    def get_year_month_day(iso8601_time)
+      return [] if iso8601_time.nil?
+
+      year = iso8601_time[0..3]
+      month = iso8601_time[5..6]
+      day = iso8601_time[8..9]
+
+      { 'year' => year.to_i,
+        'month' => month.to_i,
+        'day' => day.to_i }.delete_if { |key, value| value == 0 }
+    end
+
+    def get_iso8601_from_time(time)
+      return nil if time.blank?
+
+      Time.zone.parse(time.to_s).utc.iso8601
+    end
+
+    def get_iso8601_from_epoch(epoch)
+      return nil if epoch.blank?
+
+      # handle milliseconds
+      epoch = epoch.to_i
+      epoch = epoch / 1000 if epoch > 9999999999
+      Time.at(epoch).utc.iso8601
+    end
+  end
+end

data/lib/orcid_client/metadata.rb

@@ -0,0 +1,128 @@
+module OrcidClient
+  module Metadata
+    def get_metadata(id, service, options = {})
+      case service
+      when "crossref" then get_crossref_metadata(id, options = {})
+      when "datacite" then get_datacite_metadata(id, options = {})
+      when "orcid" then get_orcid_metadata(id, options = {})
+      else
+        { "errors" => [{ "title" => 'Not found.', "status" => 404 }] }
+      end
+    end
+
+    def get_crossref_metadata(doi, options = {})
+      return {} if doi.blank?
+
+      url = "http://api.crossref.org/works/" + PostRank::URI.escape(doi)
+      response = Maremma.get(url, options.merge(host: true))
+      return response if response["errors"]
+
+      metadata = response.fetch("data", {}).fetch("message", {})
+      return { "errors" => [{ "title" => "Not found.", "status" => 404 }] } if metadata.blank?
+
+      date_parts = metadata.fetch("issued", {}).fetch("date-parts", []).first
+      year, month, day = date_parts[0], date_parts[1], date_parts[2]
+
+      # use date indexed if date issued is in the future
+      if year.nil? || Date.new(*date_parts) > Time.zone.now.to_date
+        date_parts = metadata.fetch("indexed", {}).fetch("date-parts", []).first
+        year, month, day = date_parts[0], date_parts[1], date_parts[2]
+      end
+      metadata["issued"] = { "date-parts" => [date_parts] }
+
+      metadata["title"] = case metadata["title"].length
+            when 0 then nil
+            when 1 then metadata["title"][0]
+            else metadata["title"][0].presence || metadata["title"][1]
+            end
+
+      if metadata["title"].blank? && !TYPES_WITH_TITLE.include?(metadata["type"])
+        metadata["title"] = metadata["container-title"][0].presence || "No title"
+      end
+
+      metadata["container-title"] = metadata.fetch("container-title", [])[0]
+      metadata["type"] = CROSSREF_TYPE_TRANSLATIONS[metadata["type"]] if metadata["type"]
+      metadata["author"] = metadata["author"].map { |author| author.except("affiliation") }
+
+      metadata
+    end
+
+    def get_datacite_metadata(doi, options = {})
+      return {} if doi.blank?
+
+      params = { q: "doi:" + doi,
+                 rows: 1,
+                 fl: "doi,creator,title,publisher,publicationYear,resourceTypeGeneral,description,datacentre,datacentre_symbol,prefix,relatedIdentifier,xml,minted,updated",
+                 wt: "json" }
+      url = "http://search.datacite.org/api?" + URI.encode_www_form(params)
+      response = Maremma.get(url, options)
+      return response if response["errors"]
+
+      metadata = response.fetch("data", {}).fetch("response", {}).fetch("docs", []).first
+      return { "errors" => [{ "title" => "Not found.", "status" => 404 }] } if metadata.blank?
+
+      doi = metadata.fetch("doi", nil)
+      doi = doi.upcase if doi.present?
+      title = metadata.fetch("title", []).first
+      title = title.chomp(".") if title.present?
+
+      xml = Base64.decode64(metadata.fetch('xml', "PGhzaD48L2hzaD4=\n"))
+      xml = Hash.from_xml(xml).fetch("resource", {})
+      authors = xml.fetch("creators", {}).fetch("creator", [])
+      authors = [authors] if authors.is_a?(Hash)
+
+      { "author" => get_hashed_authors(authors),
+        "title" => title,
+        "container-title" => metadata.fetch("publisher", nil),
+        "description" => metadata.fetch("description", nil),
+        "published" => metadata.fetch("publicationYear", nil),
+        "issued" => metadata.fetch("minted", nil),
+        "DOI" => doi,
+        "type" => metadata.fetch("resourceTypeGeneral", nil),
+        "subtype" => metadata.fetch("resourceType", nil),
+        "publisher_id" => metadata.fetch("datacentre_symbol", nil) }
+    end
+
+    def get_orcid_metadata(orcid, options = {})
+      return {} if orcid.blank?
+
+      url = "http://pub.orcid.org/v1.2/#{orcid}/orcid-bio"
+      response = Maremma.get(url, options)
+      return response if response["errors"]
+
+      metadata = response.fetch("data", {}).fetch("orcid_message", {}).fetch("orcid_profile", nil)
+      metadata.extend Hashie::Extensions::DeepFetch
+
+      personal_details = metadata.deep_fetch("orcid_bio", "personal_details") { {} }
+      personal_details.extend Hashie::Extensions::DeepFetch
+
+      author = { "family" => personal_details.fetch("family_name", nil),
+                 "given" => personal_details.fetch("given_names", nil) }
+      url = metadata.deep_fetch("orcid_identifier", "uri") { nil }
+      timestamp = Time.zone.now.utc.iso8601
+
+      { "author" => [author],
+        "title" => "ORCID record for #{author.fetch('given', '')} #{author.fetch('family', '')}",
+        "container-title" => "ORCID Registry",
+        "issued" => get_date_parts(timestamp),
+        "timestamp" => timestamp,
+        "URL" => url,
+        "type" => 'entry' }
+    end
+
+    def get_doi_ra(doi, options = {})
+      return {} if doi.blank?
+
+      url = "http://doi.crossref.org/doiRA/" + CGI.unescape(doi)
+      response = Maremma.get(url, options.merge(host: true))
+      return response if response["errors"]
+
+      ra = response.fetch("data", {}).first.fetch("RA", nil)
+      if ra.present?
+        ra.delete(' ').downcase
+      else
+        { "errors" => [{ "title" => "An error occured", "status" => 400 }] }
+      end
+    end
+  end
+end

data/lib/orcid_client/notification.rb

@@ -0,0 +1,125 @@
+require 'active_support/all'
+require 'nokogiri'
+
+require_relative 'api'
+require_relative 'author'
+require_relative 'base'
+require_relative 'date'
+require_relative 'metadata'
+
+module OrcidClient
+  class Notification
+    include OrcidClient::Base
+    include OrcidClient::Metadata
+    include OrcidClient::Author
+    include OrcidClient::Date
+    include OrcidClient::Api
+
+    attr_reader :doi, :orcid, :schema, :notification_access_token, :put_code, :subject, :intro, :notification_host, :validation_errors
+
+    def initialize(doi:, orcid:, notification_access_token:, **options)
+      @doi = doi
+      @orcid = orcid
+      @notification_access_token = notification_access_token
+      @put_code = options.fetch(:put_code, nil)
+      @subject = options.fetch(:subject, nil)
+      @intro = options.fetch(:intro, nil)
+      @notification_host = options[:sandbox] ? 'sandbox.orcid.org' : 'orcid.org'
+    end
+
+    SCHEMA = File.expand_path("../../../resources/notification_#{API_VERSION}/notification-permission-#{API_VERSION}.xsd", __FILE__)
+
+    def metadata
+      @metadata ||= get_metadata(doi, 'datacite')
+    end
+
+    def item_name
+      metadata.fetch('title', nil)
+    end
+
+    def item_type
+      "work"
+    end
+
+    def has_required_elements?
+      doi && item_name
+    end
+
+    def data
+      return nil unless has_required_elements?
+
+      Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+        xml.send(:'notification:notification', root_attributes) do
+          insert_notification(xml)
+        end
+      end.to_xml
+    end
+
+    def insert_notification(xml)
+      insert_notification_type(xml)
+      insert_authorization_url(xml)
+      insert_notification_subject(xml)
+      insert_notification_intro(xml)
+      insert_items(xml)
+    end
+
+    def insert_notification_type(xml)
+      xml.send(:'notification:notification-type', "permission")
+    end
+
+    def insert_authorization_url(xml)
+      xml.send(:'notification:authorization-url') do
+        xml.send(:'notification:path', work_notification_path)
+        xml.send(:'notification:host', notification_host)
+      end
+    end
+
+    def work_notification_path
+      "/oauth/authorize?client_id=#{ENV['ORCID_CLIENT_ID']}&response_type=code&scope=/read-limited%20/activities/update%20/person/update&redirect_uri=#{ENV['REDIRECT_URI']}"
+    end
+
+    def insert_notification_subject(xml)
+      xml.send(:'notification:notification-subject', subject)
+    end
+
+    def insert_notification_intro(xml)
+      xml.send(:'notification:notification-intro', intro)
+    end
+
+    def insert_items(xml)
+      return nil unless has_required_elements?
+
+      xml.send(:'notification:items') do
+        xml.send(:'notification:item') do
+          xml.send(:'notification:item-type', item_type)
+          xml.send(:'notification:item-name', item_name)
+
+          insert_id(xml, "doi", doi, "self")
+        end
+      end
+    end
+
+    def insert_id(xml, id_type, value, relationship)
+      xml.send(:'common:external-id') do
+        xml.send(:'common:external-id-type', id_type)
+        xml.send(:'common:external-id-value', value)
+        xml.send(:'common:external-id-relationship', relationship)
+      end
+    end
+
+    def root_attributes
+      { :'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+        :'xsi:schemaLocation' => 'http://www.orcid.org/ns/notification ../notification-permission-2.0_rc3.xsd',
+        :'xmlns:common' => 'http://www.orcid.org/ns/common',
+        :'xmlns:notification' => 'http://www.orcid.org/ns/notification' }
+    end
+
+    def schema
+      Nokogiri::XML::Schema(open(SCHEMA))
+    end
+
+    def validation_errors
+      @validation_errors ||= schema.validate(Nokogiri::XML(data)).map { |error| error.to_s }
+    end
+  end
+end

data/lib/orcid_client/version.rb

@@ -0,0 +1,3 @@
+module OrcidClient
+  VERSION = "0.1"
+end

data/lib/orcid_client/work.rb

@@ -0,0 +1,200 @@
+require 'active_support/all'
+require 'nokogiri'
+require 'sanitize'
+
+require_relative 'api'
+require_relative 'author'
+require_relative 'base'
+require_relative 'date'
+require_relative 'metadata'
+require_relative 'work_type'
+
+module OrcidClient
+  class Work
+    include OrcidClient::Base
+    include OrcidClient::Metadata
+    include OrcidClient::Author
+    include OrcidClient::Date
+    include OrcidClient::WorkType
+    include OrcidClient::Api
+
+    attr_reader :doi, :orcid, :schema, :access_token, :put_code, :validation_errors
+
+    def initialize(doi:, orcid:, access_token:, **options)
+      @doi = doi
+      @orcid = orcid
+      @access_token = access_token
+      @put_code = options.fetch(:put_code, nil)
+    end
+
+    SCHEMA = File.expand_path("../../../resources/record_#{API_VERSION}/work-#{API_VERSION}.xsd", __FILE__)
+
+    def metadata
+      @metadata ||= get_metadata(doi, 'datacite')
+    end
+
+    def contributors
+      Array(metadata.fetch('author', nil)).map do |contributor|
+        { orcid: contributor.fetch('ORCID', nil),
+          credit_name: get_credit_name(contributor),
+          role: nil }.compact
+      end
+    end
+
+    def author_string
+      Array(metadata.fetch('author', nil)).map do |contributor|
+        get_full_name(contributor)
+      end.join(" and ")
+    end
+
+    def sanitize(string)
+      Sanitize.fragment(string).squish
+    end
+
+    def title
+      metadata.fetch('title', nil)
+    end
+
+    def container_title
+      metadata.fetch('container-title', nil)
+    end
+
+    def publisher_id
+      metadata.fetch('publisher_id', nil)
+    end
+
+    def publication_date
+      get_year_month_day(metadata.fetch('published', nil))
+    end
+
+    def description
+      sanitize(Array(metadata.fetch('description', nil)).first)
+    end
+
+    def type
+      orcid_work_type(metadata.fetch('type', nil), metadata.fetch('subtype', nil))
+    end
+
+    def has_required_elements?
+      doi && contributors && title && container_title && publication_date
+    end
+
+    def data
+      return nil unless has_required_elements?
+
+      Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+        xml.send(:'work:work', root_attributes) do
+          insert_work(xml)
+        end
+      end.to_xml
+    end
+
+    def insert_work(xml)
+      insert_titles(xml)
+      insert_description(xml)
+      insert_type(xml)
+      insert_pub_date(xml)
+      insert_ids(xml)
+      insert_contributors(xml)
+    end
+
+    def insert_titles(xml)
+      if title
+        xml.send(:'work:title') do
+          xml.send(:'common:title', title)
+        end
+      end
+
+      xml.send(:'work:journal-title', container_title) if container_title
+    end
+
+    def insert_description(xml)
+      return nil unless description.present?
+
+      xml.send(:'work:short-description', description.truncate(2500, separator: ' '))
+    end
+
+    def insert_type(xml)
+      xml.send(:'work:type', type)
+    end
+
+    def insert_pub_date(xml)
+      if publication_date['year']
+        xml.send(:'common:publication-date') do
+          xml.year(publication_date.fetch('year'))
+          xml.month(publication_date.fetch('month', nil)) if publication_date['month']
+          xml.day(publication_date.fetch('day', nil)) if publication_date['month'] && publication_date['day']
+        end
+      end
+    end
+
+    def insert_ids(xml)
+      xml.send(:'common:external-ids') do
+        insert_id(xml, 'doi', doi, 'self')
+      end
+    end
+
+    def insert_id(xml, id_type, value, relationship)
+      xml.send(:'common:external-id') do
+        xml.send(:'common:external-id-type', id_type)
+        xml.send(:'common:external-id-value', value)
+        xml.send(:'common:external-id-relationship', relationship)
+      end
+    end
+
+    def insert_contributors(xml)
+      return nil unless contributors.present?
+
+      xml.send(:'work:contributors') do
+        contributors.each do |contributor|
+          xml.contributor do
+            insert_contributor(xml, contributor)
+          end
+        end
+      end
+    end
+
+    def insert_contributor(xml, contributor)
+      if contributor[:orcid].present?
+        xml.send(:'common:contributor-orcid') do
+          xml.send(:'common:uri', contributor[:orcid])
+          xml.send(:'common:path', contributor[:orcid][17..-1])
+          xml.send(:'common:host', 'orcid.org')
+        end
+      end
+      xml.send(:'credit-name', contributor[:credit_name])
+      if contributor[:role]
+        xml.send(:'contributor-attributes') do
+          xml.send(:'contributor-role', contributor[:role])
+        end
+      end
+    end
+
+    def without_control(s)
+      r = ''
+      s.each_codepoint do |c|
+        if c >= 32
+          r << c
+        end
+      end
+      r
+    end
+
+    def root_attributes
+      { :'put-code' => put_code,
+        :'visibility' => 'public',
+        :'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+        :'xsi:schemaLocation' => 'http://www.orcid.org/ns/work ../work-2.0_rc3.xsd',
+        :'xmlns:common' => 'http://www.orcid.org/ns/common',
+        :'xmlns:work' => 'http://www.orcid.org/ns/work' }.compact
+    end
+
+    def schema
+      Nokogiri::XML::Schema(open(SCHEMA))
+    end
+
+    def validation_errors
+      @validation_errors ||= schema.validate(Nokogiri::XML(data)).map { |error| error.to_s }
+    end
+  end
+end