berkeley_library-tind 0.4.3 → 0.6.0

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,170 @@
+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?
+
+          @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
+          @ready_to_mapping ? (subfields_from_single_map + subfields_from_combined_map) : []
+        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_subfield_util.rb

@@ -0,0 +1,154 @@
+require 'marc'
+
+module BerkeleyLibrary
+  module TIND
+    module Mapping
+      module TindSubfieldUtil
+
+        def clean_subfield(subfield)
+          new_value = clr_value(subfield.value)
+          subfield.value = new_value
+        end
+
+        def fields_880_subfield6(datafields_880)
+          formated_subfield6_value_arr(fields_by(datafields_880) { |f| is_880_field?(f) })
+        end
+
+        # From all subfield 6 gotten for repeated fields - with the same tag
+        # return the first subfield 6
+        def the_first_subfield6(fields)
+          values = subfield_6_values(fields)
+          return nil if values.empty?
+
+          # keep it here, in case needed in future: this can make sure
+          # 880 and regular fields having matching sequence number
+          # subfield6_with_small_no(values)
+
+          # new implementation: keep the first subfield 6 value
+          logger.warn("#{f[0].tag} have multiple datafields with multiple subfield 6, the first subfield 6 is kept") if values.length > 1
+          Util.subfield('6', values[0])
+        end
+
+        private
+
+        def subfield6?(f)
+          !f['6'].nil?
+        end
+
+        # f.tag can be a string or integer
+        def is_880_field?(f)
+          f.tag.to_s == '880'
+        end
+
+        # return subfield6 value formated the same way for both 880 and regular datafields
+        def formated_subfield6_value(f)
+          is_880_field?(f) ? formated_subfield6_from_880(f) : formated_subfield6_from_regular_field(f)
+        end
+
+        def fields_by(fields, &block)
+          fields.select(&block)
+        end
+
+        # return array of formated subfield6 values on inputted datafields
+        def formated_subfield6_value_arr(fields_source)
+          # fields_source = is_880_field ? fields_880(datafields) : fields_regular(datafields)
+          ls = []
+          fields_source.map do |f|
+            next unless subfield6?(f)
+
+            ls << formated_subfield6_value(f)
+          end
+          ls.compact
+        end
+
+        # return formated field6 for a regular datafield
+        # tag:246, subfields: 880-02 => 880-246-02
+        def formated_subfield6_from_regular_field(f)
+          return nil unless f['6']
+
+          tag = f.tag
+          arr = f['6'].strip.split('-')
+          "#{arr[0]}-#{tag}-#{arr[1]}"
+        end
+
+        # return formated subfield6 for a 880 datafield
+        # tag: 880, subfield6: 245-01/$1  => 880-245-01
+        def formated_subfield6_from_880(f)
+          return nil unless f['6']
+
+          "#{f.tag}-#{f['6'].strip[0, 6].strip}"
+        end
+
+        # return subfields of specific code
+        # Datafield returned from Alma may have mutiple subfields with the same code
+        def subfields(field, code)
+          sf = []
+          field.each do |s|
+            next unless s.code == code
+
+            captilize_subfield(s) if code == '3'
+            sf << s
+          end
+          sf
+        end
+
+        def captilize_subfield(subfield)
+          new_value = subfield.value.capitalize
+          subfield.value = new_value
+        end
+
+        # Combine multiple subfield values based on definition from csv file
+        def combined_subfield_value(field, code, symbol)
+          sf_arr = subfields(field, code)
+          return '' if sf_arr.empty?
+
+          sf_arr.map(&:value).join(symbol) << symbol # symbol exmaple ' -- '
+        end
+
+        # Mutilpe subfields in one field may have the same name
+        # Get all subfields on 'from subfield name'
+        # Change subfield names with 'to subfield name'
+        def subfields_from_to(field, from, to)
+          subfield_arr = subfields(field, from)
+          subfield_arr.each { |sf| sf.code = to } if !subfield_arr.empty? && (from != to)
+          subfield_arr
+        end
+
+        def subfield6_endwith_00?(f)
+          return false unless is_880_field?(f)
+
+          two_digits = f['6'].strip.split('-')[1][0..1]
+          two_digits.to_s == '00'
+        end
+
+        def fields_with_subfield6(fields)
+          fields.select { |f| subfield6?(f) }
+        end
+
+        # return subfield 6 with the smallest sequence number
+        def subfield_6_values(fields)
+          fields_with_subfield6(fields).map(&:value)
+        end
+
+        def subfield6_value_with_lowest_seq_no(values)
+          seq = 9999
+          txt = nil
+          values.each do |val|
+            num = seq_no(val)
+            if (num > 0) && (num < seq)
+              seq = num
+              txt = val
+            end
+          end
+          txt
+        end
+
+        # return all subfields except subfield6
+        def subfields_without_subfield6(field)
+          field.subfields.reject { |sf| sf.code == '6' }
+        end
+
+      end
+    end
+  end
+end