next-l / enju_ndl / 530

pending completion

Build # 530

Build Type

push

travis-ci-com

Committed by

nabeta

Commit Message

<a href="https://github.com/next-l/enju_ndl/commit/<a class=hub.com/next-l/enju_ndl/commit/40e7bd515f659c11e19a7e5c4f0d8e204ddf601a">40e7bd515<a href="https://github.com/next-l/enju_ndl/commit/40e7bd515f659c11e19a7e5c4f0d8e204ddf601a">&quot;&gt;Revert &amp;quot;move modules to app/models/concerns&quot;

This reverts commit </a><a class="double-link" href="https://github.com/next-l/enju_ndl/commit/<a class="double-link" href="https://github.com/next-l/enju_ndl/commit/3d9b0fe20bfe3a54c0cb735af74dea4f03d9f1c0">3d9b0fe20</a>">3d9b0fe20</a><a href="https://github.com/next-l/enju_ndl/commit/40e7bd515f659c11e19a7e5c4f0d8e204ddf601a">.

Run Details

251 of 251 new or added lines in 3 files covered. (100.0%)

6120 of 6409 relevant lines covered (95.49%)

293.87 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.96

/lib/enju_ndl/ndl_search.rb


module EnjuNdl
  module NdlSearch
    def self.included(base)
      base.extend ClassMethods
    end

    module ClassMethods
      def import_isbn(isbn)
        manifestation = Manifestation.import_from_ndl_search(isbn: isbn)
        manifestation
      end

      # Use http://www.ndl.go.jp/jp/dlib/standards/opendataset/aboutIDList.txt
      def import_ndl_bib_id(ndl_bib_id)
        url = "https://iss.ndl.go.jp/books/R100000002-I#{ndl_bib_id}-00.rdf"
        doc = Nokogiri::XML(Faraday.get(url).body)
        import_record(doc)
      end

      def import_from_ndl_search(options)
        # if options[:isbn]
        lisbn = Lisbn.new(options[:isbn])
        raise EnjuNdl::InvalidIsbn unless lisbn.valid?
        # end

        manifestation = Manifestation.find_by_isbn(lisbn.isbn)
        return manifestation.first if manifestation.present?

        doc = return_xml(lisbn.isbn)
        raise EnjuNdl::RecordNotFound unless doc
        # raise EnjuNdl::RecordNotFound if doc.at('//openSearch:totalResults').content.to_i == 0
        import_record(doc)
      end

      def import_record(doc)
        iss_itemno = URI.parse(doc.at('//dcndl:BibAdminResource[@rdf:about]').values.first).path.split('/').last
        identifier_type = IdentifierType.where(name: 'iss_itemno').first
        identifier_type ||= IdentifierType.where(name: 'iss_itemno').create!
        identifier = Identifier.where(body: iss_itemno, identifier_type_id: identifier_type.id).first
        return identifier.manifestation if identifier

        jpno = doc.at('//dcterms:identifier[@rdf:datatype="http://ndl.go.jp/dcndl/terms/JPNO"]').try(:content)

        publishers = get_publishers(doc)

        # title
        title = get_title(doc)

        # date of publication
        pub_date = doc.at('//dcterms:issued').try(:content).to_s.tr('.', '-')
        pub_date = nil unless pub_date =~ /^\d+(-\d{0,2}){0,2}$/
        if pub_date
          date = pub_date.split('-')
          date = if date[0] && date[1]
                   format('%04d-%02d', date[0], date[1])
                 else
                   pub_date
                 end
        end

        language = Language.where(iso_639_2: get_language(doc)).first
        language_id = if language
                        language.id
                      else
                        1
                      end

        isbn = Lisbn.new(doc.at('//dcterms:identifier[@rdf:datatype="http://ndl.go.jp/dcndl/terms/ISBN"]').try(:content).to_s).try(:isbn)
        issn = StdNum::ISSN.normalize(doc.at('//dcterms:identifier[@rdf:datatype="http://ndl.go.jp/dcndl/terms/ISSN"]').try(:content))
        issn_l = StdNum::ISSN.normalize(doc.at('//dcterms:identifier[@rdf:datatype="http://ndl.go.jp/dcndl/terms/ISSNL"]').try(:content))

        carrier_type = content_type = nil
        is_serial = nil
        doc.xpath('//dcndl:materialType[@rdf:resource]').each do |d|
          case d.attributes['resource'].try(:content)
          when 'http://ndl.go.jp/ndltype/Book'
            carrier_type = CarrierType.where(name: 'print').first
            content_type = ContentType.where(name: 'text').first
          when 'http://ndl.go.jp/ndltype/Braille'
            content_type = ContentType.where(name: 'tactile_text').first
          # when 'http://ndl.go.jp/ndltype/ComputerProgram'
          #  content_type = ContentType.where(name: 'computer_program').first
          when 'http://ndl.go.jp/ndltype/ElectronicResource'
            carrier_type = CarrierType.where(name: 'file').first
          when 'http://ndl.go.jp/ndltype/Journal'
            is_serial = true
          when 'http://ndl.go.jp/ndltype/Map'
            content_type = ContentType.where(name: 'cartographic_image').first
          when 'http://ndl.go.jp/ndltype/Music'
            content_type = ContentType.where(name: 'performed_music').first
          when 'http://ndl.go.jp/ndltype/MusicScore'
            content_type = ContentType.where(name: 'notated_music').first
          when 'http://ndl.go.jp/ndltype/Painting'
            content_type = ContentType.where(name: 'still_image').first
          when 'http://ndl.go.jp/ndltype/Photograph'
            content_type = ContentType.where(name: 'still_image').first
          when 'http://ndl.go.jp/ndltype/PicturePostcard'
            content_type = ContentType.where(name: 'still_image').first
          when 'http://purl.org/dc/dcmitype/MovingImage'
            content_type = ContentType.where(name: 'two_dimensional_moving_image').first
          when 'http://purl.org/dc/dcmitype/Sound'
            content_type = ContentType.where(name: 'sounds').first
          when 'http://purl.org/dc/dcmitype/StillImage'
            content_type = ContentType.where(name: 'still_image').first
          end
        end

        admin_identifier = doc.at('//dcndl:BibAdminResource[@rdf:about]').attributes['about'].value
        description = doc.at('//dcterms:abstract').try(:content)
        price = doc.at('//dcndl:price').try(:content)
        volume_number_string = doc.at('//dcndl:volume/rdf:Description/rdf:value').try(:content)
        extent = get_extent(doc)
        publication_periodicity = doc.at('//dcndl:publicationPeriodicity').try(:content)
        statement_of_responsibility = doc.xpath('//dcndl:BibResource/dc:creator').map(&:content).join('; ')
        publication_place = doc.at('//dcterms:publisher/foaf:Agent/dcndl:location').try(:content)
        edition_string = doc.at('//dcndl:edition').try(:content)

        manifestation = Manifestation.where(manifestation_identifier: admin_identifier).first
        return manifestation if manifestation

        Agent.transaction do
          publisher_agents = Agent.import_agents(publishers)

          manifestation = Manifestation.new(
            manifestation_identifier: admin_identifier,
            original_title: title[:manifestation],
            title_transcription: title[:transcription],
            title_alternative: title[:alternative],
            title_alternative_transcription: title[:alternative_transcription],
            # TODO: NDLサーチに入っている図書以外の資料を調べる
            #:carrier_type_id => CarrierType.where(name: 'print').first.id,
            language_id: language_id,
            pub_date: date,
            description: description,
            volume_number_string: volume_number_string,
            price: price,
            statement_of_responsibility: statement_of_responsibility,
            start_page: extent[:start_page],
            end_page: extent[:end_page],
            height: extent[:height],
            extent: extent[:extent],
            dimensions: extent[:dimensions],
            publication_place: publication_place,
            edition_string: edition_string
          )
          manifestation.serial = true if is_serial
          identifier = {}
          if isbn
            identifier[:isbn] = Identifier.new(body: isbn)
            identifier[:isbn].identifier_type = IdentifierType.where(name: 'isbn').first || IdnetifierType.create!(name: 'isbn')
          end
          if iss_itemno
            identifier[:iss_itemno] = Identifier.new(body: iss_itemno)
            identifier[:iss_itemno].identifier_type = IdentifierType.where(name: 'iss_itemno').first || IdentifierType.create!(name: 'iss_itemno')
          end
          if jpno
            identifier[:jpno] = Identifier.new(body: jpno)
            identifier[:jpno].identifier_type = IdentifierType.where(name: 'jpno').first || IdentifierType.create!(name: 'jpno')
          end
          if issn
            identifier[:issn] = Identifier.new(body: issn)
            identifier[:issn].identifier_type = IdentifierType.where(name: 'issn').first || IdentifierType.create!(name: 'issn')
          end
          if issn_l
            identifier[:issn_l] = Identifier.new(body: issn_l)
            identifier[:issn_l].identifier_type = IdentifierType.where(name: 'issn_l').first || IdentifierType.create!(name: 'issn_l')
          end
          manifestation.carrier_type = carrier_type if carrier_type
          manifestation.manifestation_content_type = content_type if content_type
          if manifestation.save
            identifier.each do |_k, v|
              manifestation.identifiers << v if v.valid?
            end
            manifestation.publishers << publisher_agents
            create_additional_attributes(doc, manifestation)
            if is_serial
              series_statement = SeriesStatement.new(
                original_title: title[:manifestation],
                title_alternative: title[:alternative],
                title_transcription: title[:transcription],
                series_master: true
              )
              if series_statement.valid?
                manifestation.series_statements << series_statement
              end
            else
              create_series_statement(doc, manifestation)
            end
          end
        end

        # manifestation.send_later(:create_frbr_instance, doc.to_s)
        manifestation
      end

      def create_additional_attributes(doc, manifestation)
        title = get_title(doc)
        creators = get_creators(doc).uniq
        subjects = get_subjects(doc).uniq
        classifications = get_classifications(doc).uniq
        classification_urls = doc.xpath('//dcterms:subject[@rdf:resource]').map { |subject| subject.attributes['resource'].value }

        Agent.transaction do
          creator_agents = Agent.import_agents(creators)
          content_type_id = begin
                              ContentType.where(name: 'text').first.id
                            rescue
                              1
                            end
          manifestation.creators << creator_agents

          if defined?(EnjuSubject)
            subject_heading_type = SubjectHeadingType.where(name: 'ndlsh').first || SubjectHeadingType.create!(name: 'ndlsh')
            subjects.each do |term|
              subject = Subject.where(term: term[:term]).first
              unless subject
                subject = Subject.new(term)
                subject.subject_heading_type = subject_heading_type
                subject.subject_type = SubjectType.where(name: 'concept').first || SubjectType.create!(name: 'concept')
              end
              # if subject.valid?
              manifestation.subjects << subject
              # end
              # subject.save!
            end
            if classification_urls
              classification_urls.each do |url|
                begin
                  ndc_url = URI.parse(URI.escape(url))
                rescue URI::InvalidURIError
                end
                next unless ndc_url
                ndc_type = ndc_url.path.split('/').reverse[1]
                next unless (ndc_type == 'ndc9') || (ndc_type == 'ndc10')
                ndc = ndc_url.path.split('/').last
                classification_type = ClassificationType.where(name: ndc_type).first || ClassificationType.create!(name: ndc_type)
                classification = Classification.new(category: ndc)
                classification.classification_type = classification_type
                manifestation.classifications << classification if classification.valid?
              end
            end
            ndc8 = doc.xpath('//dc:subject[@rdf:datatype="http://ndl.go.jp/dcndl/terms/NDC8"]').first
            if ndc8
              classification_type = ClassificationType.where(name: 'ndc8').first || ClassificationType.create!(name: 'ndc8')
              classification = Classification.new(category: ndc8.content)
              classification.classification_type = classification_type
              manifestation.classifications << classification if classification.valid?
            end
          end
        end
      end

      def search_ndl(query, options = {})
        options = { dpid: 'iss-ndl-opac', item: 'any', idx: 1, per_page: 10, raw: false, mediatype: 1 }.merge(options)
        doc = nil
        results = {}
        startrecord = options[:idx].to_i
        startrecord = 1 if startrecord == 0
        url = "https://iss.ndl.go.jp/api/opensearch?dpid=#{options[:dpid]}&#{options[:item]}=#{format_query(query)}&cnt=#{options[:per_page]}&idx=#{startrecord}&mediatype=#{options[:mediatype]}"
        if options[:raw] == true
          Faraday.get(url).body
        else
          RSS::Rss::Channel.install_text_element('openSearch:totalResults', 'http://a9.com/-/spec/opensearchrss/1.0/', '?', 'totalResults', :text, 'openSearch:totalResults')
          RSS::BaseListener.install_get_text_element 'http://a9.com/-/spec/opensearchrss/1.0/', 'totalResults', 'totalResults='
          feed = RSS::Parser.parse(url, false)
        end
      end

      def normalize_isbn(isbn)
        if isbn.length == 10
          Lisbn.new(isbn).isbn13
        else
          Lisbn.new(isbn).isbn10
        end
      end

      def return_xml(isbn)
        rss = search_ndl(isbn, dpid: 'iss-ndl-opac', item: 'isbn')
        if rss.channel.totalResults.to_i == 0
          isbn = normalize_isbn(isbn)
          rss = search_ndl(isbn, dpid: 'iss-ndl-opac', item: 'isbn')
        end
        if rss.items.first
          doc = Nokogiri::XML(Faraday.get("#{rss.items.first.link}.rdf").body)
        end
      end

      private

      def get_title(doc)
        title = {
          manifestation: doc.xpath('//dc:title/rdf:Description/rdf:value').collect(&:content).join(' '),
          transcription: doc.xpath('//dc:title/rdf:Description/dcndl:transcription').collect(&:content).join(' '),
          alternative: doc.at('//dcndl:alternative/rdf:Description/rdf:value').try(:content),
          alternative_transcription: doc.at('//dcndl:alternative/rdf:Description/dcndl:transcription').try(:content)
        }
        volumeTitle = doc.at('//dcndl:volumeTitle/rdf:Description/rdf:value').try(:content)
        volumeTitle_transcription = doc.at('//dcndl:volumeTitle/rdf:Description/dcndl:transcription').try(:content)
        title[:manifestation] << " #{volumeTitle}" if volumeTitle
        title[:transcription] << " #{volumeTitle_transcription}" if volumeTitle_transcription
        title
      end

      def get_creators(doc)
        creators = []
        doc.xpath('//dcterms:creator/foaf:Agent').each do |creator|
          creators << {
            full_name: creator.at('./foaf:name').content,
            full_name_transcription: creator.at('./dcndl:transcription').try(:content),
            agent_identifier: creator.attributes['about'].try(:content)
          }
        end
        creators
      end

      def get_subjects(doc)
        subjects = []
        doc.xpath('//dcterms:subject/rdf:Description').each do |subject|
          subjects << {
            term: subject.at('./rdf:value').content,
            #:url => subject.attribute('about').try(:content)
          }
        end
        subjects
      end

      def get_classifications(doc)
        classifications = []
        doc.xpath('//dcterms:subject[@rdf:resource]').each do |classification|
          classifications << {
            url: classification.attributes['resource'].content
          }
        end
        classifications
      end

      def get_language(doc)
        # TODO: 言語が複数ある場合
        language = doc.at('//dcterms:language[@rdf:datatype="http://purl.org/dc/terms/ISO639-2"]').try(:content)
        language.downcase if language
      end

      def get_publishers(doc)
        publishers = []
        doc.xpath('//dcterms:publisher/foaf:Agent').each do |publisher|
          publishers << {
            full_name: publisher.at('./foaf:name').content,
            full_name_transcription: publisher.at('./dcndl:transcription').try(:content),
            agent_identifier: publisher.attributes['about'].try(:content)
          }
        end
        publishers
      end

      def get_extent(doc)
        extent = doc.at('//dcterms:extent').try(:content)
        value = { start_page: nil, end_page: nil, height: nil }
        if extent
          extent = extent.split(';')
          page = extent[0].try(:strip)
          value[:extent] = page
          if page =~ /\d+p/
            value[:start_page] = 1
            value[:end_page] = page.to_i
          end
          height = extent[1].try(:strip)
          value[:dimensions] = height
          value[:height] = height.to_i if height =~ /\d+cm/
        end
        value
      end

      def create_series_statement(doc, manifestation)
        series = series_title = {}
        series[:title] = doc.at('//dcndl:seriesTitle/rdf:Description/rdf:value').try(:content)
        series[:title_transcription] = doc.at('//dcndl:seriesTitle/rdf:Description/dcndl:transcription').try(:content)
        series[:creator] = doc.at('//dcndl:seriesCreator').try(:content)
        if series[:title]
          series_title[:title] = series[:title].split(';')[0].strip
          if series[:title_transcription]
            series_title[:title_transcription] = series[:title_transcription].split(';')[0].strip
          end
        end

        if series_title[:title]
          series_statement = SeriesStatement.where(original_title: series_title[:title]).first
          series_statement ||= SeriesStatement.new(
            original_title: series_title[:title],
            title_transcription: series_title[:title_transcription],
            creator_string: series[:creator]
          )
        end

        if series_statement.try(:save)
          manifestation.series_statements << series_statement
        end
        manifestation
      end

      def format_query(query)
        URI.escape(query.to_s.tr('　', ' '))
      end
    end

    class AlreadyImported < StandardError
    end
  end
end

1
2	module EnjuNdl	18✔
3	module NdlSearch	18✔
4	def self.included(base)	18✔
5	base.extend ClassMethods	36✔
6	end
7
8	module ClassMethods	18✔
9	def import_isbn(isbn)	18✔
10	manifestation = Manifestation.import_from_ndl_search(isbn: isbn)	90✔
11	manifestation	90✔
12	end
13
14	# Use http://www.ndl.go.jp/jp/dlib/standards/opendataset/aboutIDList.txt
15	def import_ndl_bib_id(ndl_bib_id)	18✔
16	url = "https://iss.ndl.go.jp/books/R100000002-I#{ndl_bib_id}-00.rdf"	18✔
17	doc = Nokogiri::XML(Faraday.get(url).body)	18✔
18	import_record(doc)	18✔
19	end
20
21	def import_from_ndl_search(options)	18✔
22	# if options[:isbn]
23	lisbn = Lisbn.new(options[:isbn])	108✔
24	raise EnjuNdl::InvalidIsbn unless lisbn.valid?	108✔
25	# end
26
27	manifestation = Manifestation.find_by_isbn(lisbn.isbn)	108✔
28	return manifestation.first if manifestation.present?	108✔
29
30	doc = return_xml(lisbn.isbn)	108✔
31	raise EnjuNdl::RecordNotFound unless doc	108✔
32	# raise EnjuNdl::RecordNotFound if doc.at('//openSearch:totalResults').content.to_i == 0
33	import_record(doc)	108✔
34	end
35
36	def import_record(doc)	18✔
37	iss_itemno = URI.parse(doc.at('//dcndl:BibAdminResource[@rdf:about]').values.first).path.split('/').last	612✔
38	identifier_type = IdentifierType.where(name: 'iss_itemno').first	612✔
39	identifier_type \|\|= IdentifierType.where(name: 'iss_itemno').create!	612✔
40	identifier = Identifier.where(body: iss_itemno, identifier_type_id: identifier_type.id).first	612✔
41	return identifier.manifestation if identifier	612✔
42
43	jpno = doc.at('//dcterms:identifier[@rdf:datatype="http://ndl.go.jp/dcndl/terms/JPNO"]').try(:content)	612✔
44
45	publishers = get_publishers(doc)	612✔
46
47	# title
48	title = get_title(doc)	612✔
49
50	# date of publication
51	pub_date = doc.at('//dcterms:issued').try(:content).to_s.tr('.', '-')	612✔
52	pub_date = nil unless pub_date =~ /^\d+(-\d{0,2}){0,2}$/	612✔
53	if pub_date	612✔
54	date = pub_date.split('-')	594✔
55	date = if date[0] && date[1]	594✔
56	format('%04d-%02d', date[0], date[1])	18✔
57	else
58	pub_date	576✔
59	end
60	end
61
62	language = Language.where(iso_639_2: get_language(doc)).first	612✔
63	language_id = if language	612✔
64	language.id	576✔
65	else
66	1	36✔
67	end
68
69	isbn = Lisbn.new(doc.at('//dcterms:identifier[@rdf:datatype="http://ndl.go.jp/dcndl/terms/ISBN"]').try(:content).to_s).try(:isbn)	612✔
70	issn = StdNum::ISSN.normalize(doc.at('//dcterms:identifier[@rdf:datatype="http://ndl.go.jp/dcndl/terms/ISSN"]').try(:content))	612✔
71	issn_l = StdNum::ISSN.normalize(doc.at('//dcterms:identifier[@rdf:datatype="http://ndl.go.jp/dcndl/terms/ISSNL"]').try(:content))	612✔
72
73	carrier_type = content_type = nil	612✔
74	is_serial = nil	612✔
75	doc.xpath('//dcndl:materialType[@rdf:resource]').each do \|d\|	612✔
76	case d.attributes['resource'].try(:content)	864✔
77	when 'http://ndl.go.jp/ndltype/Book'
78	carrier_type = CarrierType.where(name: 'print').first	396✔
79	content_type = ContentType.where(name: 'text').first	396✔
80	when 'http://ndl.go.jp/ndltype/Braille'
81	content_type = ContentType.where(name: 'tactile_text').first	18✔
82	# when 'http://ndl.go.jp/ndltype/ComputerProgram'
83	# content_type = ContentType.where(name: 'computer_program').first
84	when 'http://ndl.go.jp/ndltype/ElectronicResource'
85	carrier_type = CarrierType.where(name: 'file').first	×
86	when 'http://ndl.go.jp/ndltype/Journal'
87	is_serial = true	72✔
88	when 'http://ndl.go.jp/ndltype/Map'
89	content_type = ContentType.where(name: 'cartographic_image').first	18✔
90	when 'http://ndl.go.jp/ndltype/Music'
91	content_type = ContentType.where(name: 'performed_music').first	18✔
92	when 'http://ndl.go.jp/ndltype/MusicScore'
93	content_type = ContentType.where(name: 'notated_music').first	18✔
94	when 'http://ndl.go.jp/ndltype/Painting'
95	content_type = ContentType.where(name: 'still_image').first	18✔
96	when 'http://ndl.go.jp/ndltype/Photograph'
97	content_type = ContentType.where(name: 'still_image').first	18✔
98	when 'http://ndl.go.jp/ndltype/PicturePostcard'
99	content_type = ContentType.where(name: 'still_image').first	18✔
100	when 'http://purl.org/dc/dcmitype/MovingImage'
101	content_type = ContentType.where(name: 'two_dimensional_moving_image').first	18✔
102	when 'http://purl.org/dc/dcmitype/Sound'
103	content_type = ContentType.where(name: 'sounds').first	18✔
104	when 'http://purl.org/dc/dcmitype/StillImage'
105	content_type = ContentType.where(name: 'still_image').first	72✔
106	end
107	end
108
109	admin_identifier = doc.at('//dcndl:BibAdminResource[@rdf:about]').attributes['about'].value	612✔
110	description = doc.at('//dcterms:abstract').try(:content)	612✔
111	price = doc.at('//dcndl:price').try(:content)	612✔
112	volume_number_string = doc.at('//dcndl:volume/rdf:Description/rdf:value').try(:content)	612✔
113	extent = get_extent(doc)	612✔
114	publication_periodicity = doc.at('//dcndl:publicationPeriodicity').try(:content)	612✔
115	statement_of_responsibility = doc.xpath('//dcndl:BibResource/dc:creator').map(&:content).join('; ')	612✔
116	publication_place = doc.at('//dcterms:publisher/foaf:Agent/dcndl:location').try(:content)	612✔
117	edition_string = doc.at('//dcndl:edition').try(:content)	612✔
118
119	manifestation = Manifestation.where(manifestation_identifier: admin_identifier).first	612✔
120	return manifestation if manifestation	612✔
121
122	Agent.transaction do	612✔
123	publisher_agents = Agent.import_agents(publishers)	612✔
124
125	manifestation = Manifestation.new(	612✔
126	manifestation_identifier: admin_identifier,
127	original_title: title[:manifestation],
128	title_transcription: title[:transcription],
129	title_alternative: title[:alternative],
130	title_alternative_transcription: title[:alternative_transcription],
131	# TODO: NDLサーチに入っている図書以外の資料を調べる
132	#:carrier_type_id => CarrierType.where(name: 'print').first.id,
133	language_id: language_id,
134	pub_date: date,
135	description: description,
136	volume_number_string: volume_number_string,
137	price: price,
138	statement_of_responsibility: statement_of_responsibility,
139	start_page: extent[:start_page],
140	end_page: extent[:end_page],
141	height: extent[:height],
142	extent: extent[:extent],
143	dimensions: extent[:dimensions],
144	publication_place: publication_place,
145	edition_string: edition_string
146	)
147	manifestation.serial = true if is_serial	612✔
148	identifier = {}	612✔
149	if isbn	612✔
150	identifier[:isbn] = Identifier.new(body: isbn)	612✔
151	identifier[:isbn].identifier_type = IdentifierType.where(name: 'isbn').first \|\| IdnetifierType.create!(name: 'isbn')	612✔
152	end
153	if iss_itemno	612✔
154	identifier[:iss_itemno] = Identifier.new(body: iss_itemno)	612✔
155	identifier[:iss_itemno].identifier_type = IdentifierType.where(name: 'iss_itemno').first \|\| IdentifierType.create!(name: 'iss_itemno')	612✔
156	end
157	if jpno	612✔
158	identifier[:jpno] = Identifier.new(body: jpno)	522✔
159	identifier[:jpno].identifier_type = IdentifierType.where(name: 'jpno').first \|\| IdentifierType.create!(name: 'jpno')	522✔
160	end
161	if issn	612✔
162	identifier[:issn] = Identifier.new(body: issn)	54✔
163	identifier[:issn].identifier_type = IdentifierType.where(name: 'issn').first \|\| IdentifierType.create!(name: 'issn')	54✔
164	end
165	if issn_l	612✔
166	identifier[:issn_l] = Identifier.new(body: issn_l)	54✔
167	identifier[:issn_l].identifier_type = IdentifierType.where(name: 'issn_l').first \|\| IdentifierType.create!(name: 'issn_l')	54✔
168	end
169	manifestation.carrier_type = carrier_type if carrier_type	612✔
170	manifestation.manifestation_content_type = content_type if content_type	612✔
171	if manifestation.save	612✔
172	identifier.each do \|_k, v\|	612✔
173	manifestation.identifiers << v if v.valid?	1,854✔
174	end
175	manifestation.publishers << publisher_agents	612✔
176	create_additional_attributes(doc, manifestation)	612✔
177	if is_serial	612✔
178	series_statement = SeriesStatement.new(	72✔
179	original_title: title[:manifestation],
180	title_alternative: title[:alternative],
181	title_transcription: title[:transcription],
182	series_master: true
183	)
184	if series_statement.valid?	72✔
185	manifestation.series_statements << series_statement	72✔
186	end
187	else
188	create_series_statement(doc, manifestation)	540✔
189	end
190	end
191	end
192
193	# manifestation.send_later(:create_frbr_instance, doc.to_s)
194	manifestation	612✔
195	end
196
197	def create_additional_attributes(doc, manifestation)	18✔
198	title = get_title(doc)	612✔
199	creators = get_creators(doc).uniq	612✔
200	subjects = get_subjects(doc).uniq	612✔
201	classifications = get_classifications(doc).uniq	612✔
202	classification_urls = doc.xpath('//dcterms:subject[@rdf:resource]').map { \|subject\| subject.attributes['resource'].value }	1,548✔
203
204	Agent.transaction do	612✔
205	creator_agents = Agent.import_agents(creators)	612✔
206	content_type_id = begin	612✔
207	ContentType.where(name: 'text').first.id	612✔
208	rescue
209	1	×
210	end
211	manifestation.creators << creator_agents	612✔
212
213	if defined?(EnjuSubject)	612✔
214	subject_heading_type = SubjectHeadingType.where(name: 'ndlsh').first \|\| SubjectHeadingType.create!(name: 'ndlsh')	612✔
215	subjects.each do \|term\|	612✔
216	subject = Subject.where(term: term[:term]).first	504✔
217	unless subject	504✔
218	subject = Subject.new(term)	504✔
219	subject.subject_heading_type = subject_heading_type	504✔
220	subject.subject_type = SubjectType.where(name: 'concept').first \|\| SubjectType.create!(name: 'concept')	504✔
221	end
222	# if subject.valid?
223	manifestation.subjects << subject	504✔
224	# end
225	# subject.save!
226	end
227	if classification_urls	612✔
228	classification_urls.each do \|url\|	612✔
229	begin	936✔
230	ndc_url = URI.parse(URI.escape(url))	936✔
231	rescue URI::InvalidURIError
232	end
233	next unless ndc_url	936✔
234	ndc_type = ndc_url.path.split('/').reverse[1]	900✔
235	next unless (ndc_type == 'ndc9') \|\| (ndc_type == 'ndc10')	900✔
236	ndc = ndc_url.path.split('/').last	252✔
237	classification_type = ClassificationType.where(name: ndc_type).first \|\| ClassificationType.create!(name: ndc_type)	252✔
238	classification = Classification.new(category: ndc)	252✔
239	classification.classification_type = classification_type	252✔
240	manifestation.classifications << classification if classification.valid?	252✔
241	end
242	end
243	ndc8 = doc.xpath('//dc:subject[@rdf:datatype="http://ndl.go.jp/dcndl/terms/NDC8"]').first	612✔
244	if ndc8	612✔
245	classification_type = ClassificationType.where(name: 'ndc8').first \|\| ClassificationType.create!(name: 'ndc8')	54✔
246	classification = Classification.new(category: ndc8.content)	54✔
247	classification.classification_type = classification_type	54✔
248	manifestation.classifications << classification if classification.valid?	54✔
249	end
250	end
251	end
252	end
253
254	def search_ndl(query, options = {})	18✔
255	options = { dpid: 'iss-ndl-opac', item: 'any', idx: 1, per_page: 10, raw: false, mediatype: 1 }.merge(options)	288✔
256	doc = nil	288✔
257	results = {}	288✔
258	startrecord = options[:idx].to_i	288✔
259	startrecord = 1 if startrecord == 0	288✔
260	url = "https://iss.ndl.go.jp/api/opensearch?dpid=#{options[:dpid]}&#{options[:item]}=#{format_query(query)}&cnt=#{options[:per_page]}&idx=#{startrecord}&mediatype=#{options[:mediatype]}"	288✔
261	if options[:raw] == true	288✔
262	Faraday.get(url).body	180✔
263	else
264	RSS::Rss::Channel.install_text_element('openSearch:totalResults', 'http://a9.com/-/spec/opensearchrss/1.0/', '?', 'totalResults', :text, 'openSearch:totalResults')	108✔
265	RSS::BaseListener.install_get_text_element 'http://a9.com/-/spec/opensearchrss/1.0/', 'totalResults', 'totalResults='	108✔
266	feed = RSS::Parser.parse(url, false)	108✔
267	end
268	end
269
270	def normalize_isbn(isbn)	18✔
271	if isbn.length == 10	×
272	Lisbn.new(isbn).isbn13	×
273	else
274	Lisbn.new(isbn).isbn10	×
275	end
276	end
277
278	def return_xml(isbn)	18✔
279	rss = search_ndl(isbn, dpid: 'iss-ndl-opac', item: 'isbn')	108✔
280	if rss.channel.totalResults.to_i == 0	108✔
281	isbn = normalize_isbn(isbn)	×
282	rss = search_ndl(isbn, dpid: 'iss-ndl-opac', item: 'isbn')	×
283	end
284	if rss.items.first	108✔
285	doc = Nokogiri::XML(Faraday.get("#{rss.items.first.link}.rdf").body)	108✔
286	end
287	end
288
289	private	18✔
290
291	def get_title(doc)	18✔
292	title = {	1,224✔
293	manifestation: doc.xpath('//dc:title/rdf:Description/rdf:value').collect(&:content).join(' '),
294	transcription: doc.xpath('//dc:title/rdf:Description/dcndl:transcription').collect(&:content).join(' '),
295	alternative: doc.at('//dcndl:alternative/rdf:Description/rdf:value').try(:content),
296	alternative_transcription: doc.at('//dcndl:alternative/rdf:Description/dcndl:transcription').try(:content)
297	}
298	volumeTitle = doc.at('//dcndl:volumeTitle/rdf:Description/rdf:value').try(:content)	1,224✔
299	volumeTitle_transcription = doc.at('//dcndl:volumeTitle/rdf:Description/dcndl:transcription').try(:content)	1,224✔
300	title[:manifestation] << " #{volumeTitle}" if volumeTitle	1,224✔
301	title[:transcription] << " #{volumeTitle_transcription}" if volumeTitle_transcription	1,224✔
302	title	1,224✔
303	end
304
305	def get_creators(doc)	18✔
306	creators = []	612✔
307	doc.xpath('//dcterms:creator/foaf:Agent').each do \|creator\|	612✔
308	creators << {
309	full_name: creator.at('./foaf:name').content,
310	full_name_transcription: creator.at('./dcndl:transcription').try(:content),
311	agent_identifier: creator.attributes['about'].try(:content)
312	}	864✔
313	end
314	creators	612✔
315	end
316
317	def get_subjects(doc)	18✔
318	subjects = []	612✔
319	doc.xpath('//dcterms:subject/rdf:Description').each do \|subject\|	612✔
320	subjects << {
321	term: subject.at('./rdf:value').content,
322	#:url => subject.attribute('about').try(:content)
323	}	504✔
324	end
325	subjects	612✔
326	end
327
328	def get_classifications(doc)	18✔
329	classifications = []	612✔
330	doc.xpath('//dcterms:subject[@rdf:resource]').each do \|classification\|	612✔
331	classifications << {
332	url: classification.attributes['resource'].content
333	}	936✔
334	end
335	classifications	612✔
336	end
337
338	def get_language(doc)	18✔
339	# TODO: 言語が複数ある場合
340	language = doc.at('//dcterms:language[@rdf:datatype="http://purl.org/dc/terms/ISO639-2"]').try(:content)	612✔
341	language.downcase if language	612✔
342	end
343
344	def get_publishers(doc)	18✔
345	publishers = []	612✔
346	doc.xpath('//dcterms:publisher/foaf:Agent').each do \|publisher\|	612✔
347	publishers << {
348	full_name: publisher.at('./foaf:name').content,
349	full_name_transcription: publisher.at('./dcndl:transcription').try(:content),
350	agent_identifier: publisher.attributes['about'].try(:content)
351	}	630✔
352	end
353	publishers	612✔
354	end
355
356	def get_extent(doc)	18✔
357	extent = doc.at('//dcterms:extent').try(:content)	612✔
358	value = { start_page: nil, end_page: nil, height: nil }	612✔
359	if extent	612✔
360	extent = extent.split(';')	612✔
361	page = extent[0].try(:strip)	612✔
362	value[:extent] = page	612✔
363	if page =~ /\d+p/	612✔
364	value[:start_page] = 1	306✔
365	value[:end_page] = page.to_i	306✔
366	end
367	height = extent[1].try(:strip)	612✔
368	value[:dimensions] = height	612✔
369	value[:height] = height.to_i if height =~ /\d+cm/	612✔
370	end
371	value	612✔
372	end
373
374	def create_series_statement(doc, manifestation)	18✔
375	series = series_title = {}	540✔
376	series[:title] = doc.at('//dcndl:seriesTitle/rdf:Description/rdf:value').try(:content)	540✔
377	series[:title_transcription] = doc.at('//dcndl:seriesTitle/rdf:Description/dcndl:transcription').try(:content)	540✔
378	series[:creator] = doc.at('//dcndl:seriesCreator').try(:content)	540✔
379	if series[:title]	540✔
380	series_title[:title] = series[:title].split(';')[0].strip	234✔
381	if series[:title_transcription]	234✔
382	series_title[:title_transcription] = series[:title_transcription].split(';')[0].strip	108✔
383	end
384	end
385
386	if series_title[:title]	540✔
387	series_statement = SeriesStatement.where(original_title: series_title[:title]).first	234✔
388	series_statement \|\|= SeriesStatement.new(
389	original_title: series_title[:title],
390	title_transcription: series_title[:title_transcription],
391	creator_string: series[:creator]
392	)	234✔
393	end
394
395	if series_statement.try(:save)	540✔
396	manifestation.series_statements << series_statement	234✔
397	end
398	manifestation	540✔
399	end
400
401	def format_query(query)	18✔
402	URI.escape(query.to_s.tr('　', ' '))	288✔
403	end
404	end
405
406	class AlreadyImported < StandardError	18✔
407	end
408	end
409	end

next-l / enju_ndl / 530

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous