berkeley_library-tind 0.5.1 → 0.7.0

data/lib/berkeley_library/tind/mapping/tind_field_from_leader.rb

@@ -0,0 +1,27 @@
+require 'marc'
+require 'berkeley_library/tind/mapping/tind_control_subfield'
+
+module BerkeleyLibrary
+  module TIND
+    require 'marc'
+    module Mapping
+
+      class TindFieldFromLeader
+        include CsvMultipleMapper
+        include Util
+        include TindControlSubfield
+
+        def initialize(record)
+          @leader_value = record.leader
+        end
+
+        def to_datafields
+          leader_rules = rules[Util.tag_symbol('LDR')]
+          return [] unless @leader_value && leader_rules
+
+          extracted_fields_from_leader(leader_rules, @leader_value)
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/tind/mapping/tind_field_from_multiple_map.rb

@@ -0,0 +1,59 @@
+require 'marc'
+require 'berkeley_library/tind/mapping/tind_control_subfield'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+
+      class TindFieldFromMultipleMap
+        include CsvMultipleMapper
+        include Util
+        include TindControlSubfield
+
+        def initialize(controlfield, current_datafields)
+          @from_controlfield = controlfield
+          @current_tags = current_datafields.map(&:tag)
+        end
+
+        def to_datafields
+          datafields = []
+          control_rules = rules_on_controldatafield
+
+          if control_rules
+            control_rules.each do |rule|
+              df = to_datafield(rule)
+              datafields << df if df
+            end
+          end
+
+          datafields
+        end
+
+        private
+
+        # one control field may have multiple rules
+        def rules_on_controldatafield
+          tag = @from_controlfield.tag
+          sym = Util.tag_symbol(tag)
+          rules[sym]
+        end
+
+        # Check mapped current datafields has the pre-existed tag defined in the row (rule) of csv file
+        def pre_exsited_tag?(rule)
+          @current_tags.include? rule.pre_existed_tag.to_s
+        end
+
+        # get a datafield on a rule (row in csv file)
+        def to_datafield(rule)
+          return nil if pre_exsited_tag?(rule)
+
+          to_value = extract_value(rule, @from_controlfield.value)
+          return nil unless to_value
+
+          extracted_field(rule, to_value)
+        end
+
+      end
+    end
+  end
+end

data/lib/berkeley_library/tind/mapping/tind_field_from_single_map.rb

@@ -0,0 +1,182 @@
+require 'marc'
+require 'berkeley_library/tind/mapping/util'
+require 'berkeley_library/tind/mapping/tind_subfield_util'
+
+# 1. datafield could be a regular alma field
+# 1) data_fields_normal - using  @single_rule_hash from SingleRule
+# 2) data_fields_with_pre_existed_field - using  @single_rule_hash from SingleRule
+# 3) data_fields_with_pre_existed_subfield  - using   @single_rule_subfield_excluded_hash  from SingleRule
+
+# 2. data field could be an 880 alma field , below types are definded based on the tag from subfield6
+# 1) data_fields_normal - using  @single_rule_hash from SingleRule
+# 2) data_fields_with_pre_existed_field - using  @single_rule_hash from SingleRule
+# 3) data_fields_with_pre_existed_subfield  - using   @single_rule_subfield_excluded_hash from SingleRule
+
+# 3. map_to_tag, indicator are from mapping rule for output tindfield
+# 4. subfileds are re-mapped, or combined, used as subfields for  output tindfield
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+
+      class TindFieldFromSingleMap
+        include CsvMapper
+        include Util
+        include TindSubfieldUtil
+        include Misc
+
+        # excluding_subfield = false: mapping by rule.single_rule_hash
+        # excluding_subfield = true: mapping by rule.single_rule_subfield_excluded_hash
+        def initialize(datafield, excluding_subfield)
+          @from_datafield = datafield
+          @excluding_subfield = excluding_subfield
+
+          @is_880_field = is_880_field?(datafield)
+
+          @mapping_rule = rule
+          @map_to_tag = nil
+          @indicator = nil
+          @single_mapping = nil
+          @ready_to_mapping = ready_to_mapping?
+
+          @codes = subfield_codes(@from_datafield)
+          @to_subfields = all_subfields
+        end
+
+        def to_datafield
+          return nil unless mapped?
+
+          tindfield = Util.datafield(@map_to_tag, @indicator, @to_subfields)
+          @is_880_field ? reversed_880_field(tindfield) : tindfield
+        end
+
+        private
+
+        # A referred tag from 880 subfield6 may not have a rule
+        # For example: 880 subfild6 pass in a value in wrong format
+        # In above case, rule is nil
+        # Get mapping parameters from rule when having a rule
+        def ready_to_mapping?
+          return false unless @mapping_rule
+
+          @map_to_tag = @mapping_rule.tag_destination
+          @indicator =  @mapping_rule.indicator
+          @single_mapping = @excluding_subfield ? @mapping_rule.single_rule_subfield_excluded_hash : @mapping_rule.single_rule_hash
+
+          return false unless @map_to_tag && @indicator && !@single_mapping.empty?
+
+          true
+        end
+
+        def mapped?
+          !@to_subfields.empty?
+        end
+
+        # tag - regular alma field
+        # referred tag - got tag from subfield6 value of a 880 field
+        # nil rule caused by nil referred tag - eg. 880 subfild6 pass in a value in wrong format
+        def rule
+          tag = origin_mapping_tag(@from_datafield)
+          return nil unless tag
+
+          rules[Util.tag_symbol(tag)]
+        end
+
+        def all_subfields
+          return [] unless @ready_to_mapping
+
+          subfields = subfields_from_single_map + subfields_from_combined_map
+          codes = @mapping_rule.subfields_order || @codes
+
+          return subfields unless subfields.length > 1
+
+          Util.order_subfields(subfields, codes)
+        end
+
+        def subfield_codes(f)
+          f.subfields.map(&:code).uniq
+        end
+
+        # 1.subfields mapped with single rule, mapping one subfield to another subfield
+        # 2. one subfield is mapped to one subfield
+        # 3. When mutiple subfields with the same name found in an orignal field,
+        # they will be mapped one by one
+        def subfields_from_single_map
+          return [] if @single_mapping.empty?
+
+          mapped_subfields = []
+          @single_mapping.each do |from, to|
+            subfields = subfields_from_to(@from_datafield, from, to)
+            mapped_subfields.concat(subfields)
+          end
+          mapped_subfields
+        end
+
+        # return all subfields mapped with diferent combined rules - different destination subfield names
+        # mapped with all combined rules, exmaple: [[["a,b,c,d", "b", "--"],["o,p,q", "b", ""]],[["x,y,z", "a", "--"]]]
+        # mapping using above example rules will return two subfield: $b, $a
+        def subfields_from_combined_map
+          all_rules = @mapping_rule.combined_rules
+          return [] if all_rules.empty?
+
+          mapped_subfields = []
+          all_rules.each do |rules|
+            subfield = subfield_on_same_tosubfieldname(rules)
+            mapped_subfields.push(subfield) if subfield
+          end
+          mapped_subfields
+        end
+
+        # create one subfield with a desintaion subfield name
+        # input array of rules example: [["a,b,c,d", "b", "--"],["o,p,q", "b", ""]] -- all rules with the same destination subfield name "b"
+        # get a subfield$b with a concatenated value
+        def subfield_on_same_tosubfieldname(rules)
+          return nil if rules.empty?
+
+          val = subfield_value_on_rules(rules)
+          return nil if val.strip.empty?
+
+          subfield_name_to = rules[0][1]
+          Util.subfield(subfield_name_to, Util.remove_extra_symbol(rules, val))
+        end
+
+        # input an array of rules, example: [["a,b,c,d", "b", "--"],["o,p,q", "b", ""]]
+        # Theese rules have the same destination subfield name, for example "b" in above example
+        # get a value concatenated with values mapped using different rules
+        def subfield_value_on_rules(rules)
+          val = ''
+          rules.each { |rule| val << subfield_value_on_rule(rule) }
+          val
+        end
+
+        # input a rule (for example ["a,b,c,d", "b", "--"]),
+        # get a combined value of subfield a,b,c,d concatenated by " -- " as above example
+        # One subfield names may occurs mutiple times in a an orignal field
+        def subfield_value_on_rule(rule)
+          subfield_names_from = rule[0].strip.split(',')
+          symbol = Util.concatenation_symbol(rule[2])
+          val = ''
+          subfield_names_from.each do |subfield_name|
+            sub_val = combined_subfield_value(@from_datafield, subfield_name, symbol)
+            val << sub_val
+          end
+          val
+        end
+
+        # 880 datafield: reverse tag from 'to_tag' defined mapping rule to '880'
+        def reversed_880_field(f)
+          update_datafield6(f)
+          f.tag = '880'
+          f
+        end
+
+        # update subfield6 tag with destination tag from the rule
+        # since an origin tag may have been mapped a different tag - destination tag
+        def update_datafield6(f) # need test
+          f['6'].sub!(@mapping_rule.tag_origin, @mapping_rule.tag_destination)
+        end
+
+      end
+    end
+  end
+end

data/lib/berkeley_library/tind/mapping/tind_field_util.rb

@@ -0,0 +1,112 @@
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      module TindFieldUtil
+
+        # tag - regular alma field
+        # referred tag - got tag from subfield6 value of a 880 field
+        # nil rule caused by nil referred tag - eg. 880 subfild6 has a value in wrong format
+        def rule(field)
+          tag = origin_mapping_tag(field)
+          return nil unless tag
+
+          rules[Util.tag_symbol(tag)]
+        end
+
+        def tindfield_existed?(field, fields)
+          return false unless field_has_rule?(field)
+
+          field_rule = rule(field)
+          mapping_to_tag = field_rule.pre_existed_tag
+          return false unless mapping_to_tag
+
+          map_to_tag_existed_in_fields?(field, fields, mapping_to_tag)
+        end
+
+        # To check TIND datafield and the specific subfield  from rule existed
+        def tindfield_subfield_existed?(field, fields)
+          return false unless field_has_rule?(field)
+
+          field_rule = rule(field)
+          return false unless pre_existed_tag_subfield_in_rule?(field_rule)
+
+          tag_subfield = field_rule.pre_existed_tag_subfield
+          mapping_to_tag = tag_subfield[0]
+          return false unless map_to_tag_existed_in_fields?(field, fields, mapping_to_tag)
+
+          existed_datafield = field_pre_existed(mapping_to_tag, field, fields)
+          return false unless existed_datafield
+
+          subfield_name = tag_subfield[1]
+          existed_datafield[subfield_name] ? true : false
+        end
+
+        def field_880_on_subfield6_tag(tag, fields)
+          datafield_on_tag(tag, fields) { |f| referred_tag(f) == tag }
+        end
+
+        def field_on_tag(tag, fields)
+          datafield_on_tag(tag, fields) { |f| f.tag == tag }
+        end
+
+        private
+
+        def field_has_rule?(field)
+          field_rule = rule(field)
+          return false unless field_rule
+
+          true
+        end
+
+        def pre_existed_tag_subfield_in_rule?(rule)
+          tag_subfield = rule.pre_existed_tag_subfield
+          return false unless tag_subfield
+
+          return false unless tag_subfield.length == 2
+
+          true
+        end
+
+        def map_to_tag_existed_in_fields?(field, fields, mapping_to_tag)
+          existed_tags = if is_880_field?(field)
+                           tags_from_fields(fields) { |f| tag_from_880_subfield6(f) }
+                         else
+                           tags_from_fields(fields, &:tag)
+                         end
+
+          existed_tags.include? mapping_to_tag
+        end
+
+        # field, fields be both regular fields
+        # or field, fields be both 880 fields
+        # since a field may mapped to another one in TIND, mapping_to_tag is not always the same as field.tag
+        def field_pre_existed(mapping_to_tag, field, fields)
+          if is_880_field?(field)
+            field_880_on_subfield6_tag(mapping_to_tag,
+                                       fields)
+          else
+            field_on_tag(mapping_to_tag, fields)
+          end
+        end
+
+        def datafield_on_tag(tag, fields)
+          fields.find do |f|
+            yield(f, tag)
+          end
+        end
+
+        def tags_from_fields(fields, &block)
+          fields.map(&block)
+        end
+
+        def tag_from_880_subfield6(field)
+          field['6'].split('-')[0]
+        end
+
+      end
+
+    end
+  end
+end

data/lib/berkeley_library/tind/mapping/tind_marc.rb

@@ -0,0 +1,134 @@
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      class TindMarc
+        include CsvMapper
+        include Util
+        include TindSubfieldUtil
+        include Misc
+        include TindFieldUtil
+        include AdditionalDatafieldProcess
+        include BerkeleyLibrary::Logging
+        include MatchTindField
+
+        attr_accessor :source_marc_record
+        attr_writer :tind_external_datafields
+        attr_reader :field_catalog
+        attr_reader :mms_id
+
+        # input an alma record
+        def initialize(record)
+          @source_marc_record = record
+          @field_catalog = DataFieldsCatalog.new(@source_marc_record)
+          @tind_external_datafields = []
+        end
+
+        # return mapped tind datafields
+        # keep the order of different mapping
+        def tindfields
+          fields = []
+          fields.concat tindfields_group
+          fields.concat tindfields_group_880
+          fields
+        end
+
+        # return a TIND Marc record
+        # add external datafields
+        # flag to do additional TIND datafield process before generating a TIND Marc record
+        def tind_record
+          fields = tindfields
+          fields.concat @tind_external_datafields
+          more_process(fields)
+          record = ::MARC::Record.new
+          fields.each { |f| record.append(f) }
+          record
+        end
+
+        private
+
+        # return mapped tind datafields
+        # keep the order of different mapping
+        def tindfields_group
+          fields_from_normal = tindfields_from_normal(@field_catalog.data_fields_group[:normal])
+          fields_from_leader = TindFieldFromLeader.new(@source_marc_record).to_datafields
+
+          temp_fields = fields_from_normal.concat fields_from_leader
+          temp_fields.concat tindfields_from_control(temp_fields)
+          temp_fields.concat tindfields_with_pre_existed_field(@field_catalog.data_fields_group[:pre_tag], temp_fields)
+          temp_fields.concat tindfields_with_pre_existed_subfield(@field_catalog.data_fields_group[:pre_tag_subfield], temp_fields)
+
+          temp_fields
+        end
+
+        # return mapped tind 880 datafields
+        # keep the order of different mapping
+        def tindfields_group_880
+          fields = []
+          fields.concat tindfields_from_normal(@field_catalog.data_fields_880_group[:normal])
+          fields.concat tindfields_with_pre_existed_field(@field_catalog.data_fields_880_group[:pre_tag], fields)
+          fields.concat tindfields_with_pre_existed_subfield(@field_catalog.data_fields_880_group[:pre_tag_subfield], fields)
+          fields.concat @field_catalog.data_fields_880_00
+          fields
+        end
+
+        # # Return TIND datafields mapped in a normal way
+        # # Normal way mapping: one regular datafield is mapped one TIND datafield
+        def tindfields_from_normal(alma_fields)
+          new_fls = []
+          alma_fields.each do |f|
+            add_tindfield(new_fls, f, excluding_subfield: false)
+          end
+          new_fls
+        end
+
+        # Return TIND datafield mapped from a control datafield
+        # One control datafield could be mapped to multiple TIND datafields
+        def tindfields_from_control(currentfields)
+          new_fls = []
+          @field_catalog.control_fields.each do |f|
+            add_tindcontrolfield(new_fls, f, currentfields)
+          end
+          new_fls
+        end
+
+        # Return TIND datafields if no pre_existed field
+        def tindfields_with_pre_existed_field(alma_fields, currentfields)
+          new_fls = []
+          alma_fields.each do |f|
+            add_tindfield(new_fls, f, excluding_subfield: false) unless tindfield_existed?(f, currentfields)
+          end
+          new_fls
+        end
+
+        # Return TIND datafields considering excluding pre_existing subfields
+        def tindfields_with_pre_existed_subfield(alma_fields, currentfields)
+          new_fls = []
+          alma_fields.each do |f|
+            excluding_subfield = tindfield_subfield_existed?(f, currentfields)
+            add_tindfield(new_fls, f, excluding_subfield: excluding_subfield)
+          end
+          new_fls
+        end
+
+        def add_tindfield(fls, f, excluding_subfield: false)
+          tindfield = TindFieldFromSingleMap.new(f, excluding_subfield).to_datafield
+          fls << tindfield if tindfield
+        end
+
+        def add_tindcontrolfield(fls, f, currentfields)
+          fls.concat TindFieldFromMultipleMap.new(f, currentfields).to_datafields
+        end
+
+        # Additional processes - run in a sequence
+        def more_process(fields)
+          remove_repeats(fields)
+          clean_subfields(fields)
+          un_matched_fields_880(fields, @field_catalog.mms_id)
+        end
+
+      end
+    end
+  end
+end

data/lib/berkeley_library/tind/mapping/tind_record_util.rb

@@ -0,0 +1,135 @@
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      module TindRecordUtil
+
+        class << self
+          include TindRecordUtil
+        end
+
+        # 1) tag_subfield_hash: a hash to add a new, or update an existing subfield to a field in a TIND Marc record
+        #    If a subfield existed, it will replace the subfield, otherwise, add a new subfield
+        #    when 'a' => nil, it will skip add/update to subfield,
+        #    It can be useed in a case: only need to add/update subfields of specific records in a collection
+        #    This is an example: tag_subfield_hash = { '245' => { 'b' => 'subtitle', 'a' => 'title' }, '336' => { 'a' => nil } }
+        # 2) fields_removal_list: an array including fields' informat: tag, indicators - "[tag, inicator1, indicator2]".
+        #    This list is to remove fields in a record.
+        #    An example fields_removal_list = [%w[856 4 1], %w[041 _ _]].
+        #    '_' means an empty indicator ''
+        # 3) How to use it:
+        #   a.  add/update subfields of existed fields in record: TindRecordUtil.update_record(record, tag_subfield_hash)
+        #   b.  remove a list of fields in the record: TindRecordUtil.update_record(record, nil, fields_removal_list)
+        #   c.  both a. and b. : TindRecordUtil.update_record(record, tag_subfield_hash, fields_removal_list)
+        def update_record(record, tag_subfield_hash, fields_removal_list = nil)
+          return record unless valid_hash?(tag_subfield_hash) || valid_hash?(fields_removal_list)
+
+          fields = record.fields
+          final_fields = tag_subfield_hash ? subfields_to_existed_fields(fields, tag_subfield_hash) : fields
+          remove_fields(final_fields, fields_removal_list) if fields_removal_list
+          new_record(final_fields)
+        end
+
+        private
+
+        def subfields_to_existed_fields(fields, tag_subfield_hash)
+          updated_fields = []
+          tags = tag_subfield_hash.keys
+          fields.each do |field|
+            tag = field.tag
+            need_change_subfield = tags.include? tag
+            updated_fields << (need_change_subfield ? field_changed_subfields(field, tag_subfield_hash[tag]) : field)
+          end
+          fields
+        end
+
+        # example: fields_removal_list = [%w[856 4 1]]
+        def remove_fields(fields, fields_removal_list)
+          fields.reject! { |f| field_in_removal_list?(f, fields_removal_list) }
+        end
+
+        def new_record(fields)
+          record = ::MARC::Record.new
+          fields.each { |f| record.append(f) }
+          record
+        end
+
+        # subfield_hash example  { 'b' => 'subtitle', 'a' => 'title' }
+        def field_changed_subfields(field, subfield_hash)
+          tag = field.tag
+          indicators = [field.indicator1, field.indicator2]
+          subfields = changed_subfields(field, subfield_hash)
+          new_datafield(tag, indicators, subfields)
+        end
+
+        # example subfield_hash = { 'p' =>  'subtitle'}
+        def changed_subfields(field, subfield_hash)
+          subfields = field.subfields
+          codes = subfields.map(&:code)
+          warning_duplicated_subfield_code(codes)
+
+          keys = subfield_hash.keys
+
+          keys_no_related_codes = keys - codes
+          keys_with_related_codes = keys - keys_no_related_codes
+
+          updated_subfields(subfields, keys_with_related_codes, subfield_hash)
+
+          subfields.concat new_subfields(field, keys_no_related_codes, subfield_hash)
+          subfields
+        end
+
+        # example subfield_hash = { 'p' =>  'subtitle'}
+        def updated_subfields(subfields, existed_codes, subfield_hash)
+          subfields.each do |subfield|
+            code = subfield.code
+            next unless existed_codes.include? code
+
+            val = subfield_hash[code]
+            next unless val
+
+            subfield.value = val
+          end
+        end
+
+        def new_subfields(_field, new_codes, subfield_hash)
+          subfields = []
+          subfield_hash.each do |key, val|
+            next unless val
+
+            subfields << ::MARC::Subfield.new(key, val) if new_codes.include? key
+          end
+          subfields
+        end
+
+        def field_in_removal_list?(f, fields_removal_list)
+          ls = [f.tag, clr(f.indicator1), clr(f.indicator2)]
+          fields_removal_list.include? ls
+        end
+
+        def clr(str)
+          str.strip.empty? ? '_' : str.strip
+        end
+
+        def new_datafield(tag, indicator, subfields)
+          datafield = ::MARC::DataField.new(tag, indicator[0], indicator[1])
+          subfields.each { |sf| datafield.append(sf) }
+          datafield
+        end
+
+        # suppose there are no duplicated subfield codes in a field
+        # giving warning for investigation if finding any dublicated subfields in a field
+        def warning_duplicated_subfield_code(codes)
+          duplicated_codes = codes.select { |code| codes.count(code) > 1 }.uniq
+          puts "Warning: duplicated subfields #{duplicated_codes.join(' ; ')}" unless duplicated_codes.empty?
+        end
+
+        def valid_hash?(hash)
+          hash && !hash.empty?
+        end
+
+      end
+    end
+  end
+end