adiwg-mdtranslator 1.4.0 → 2.0.0rc2

data/lib/adiwg/mdtranslator/readers/mdJson/modules/module_taxonomicClassification.rb

@@ -0,0 +1,87 @@
+# unpack taxonomic classification
+# Reader - ADIwg JSON to internal data structure
+
+# History:
+#   Stan Smith 2017-01-31 added taxonomicSystemId
+#   Stan Smith 2016-10-22 original script
+
+require_relative 'module_taxonomicClassification'
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+
+                module TaxonomicClassification
+
+                    def self.unpack(hTaxClass, responseObj)
+
+                        # return nil object if input is empty
+                        if hTaxClass.empty?
+                            responseObj[:readerExecutionMessages] << 'Taxonomic Classification object is empty'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        # instance classes needed in script
+                        intMetadataClass = InternalMetadata.new
+                        intTaxClass = intMetadataClass.newTaxonClass
+
+                        # taxonomic classification - system ID
+                        if hTaxClass.has_key?('taxonomicSystemId')
+                            s = hTaxClass['taxonomicSystemId']
+                            unless s == ''
+                                intTaxClass[:taxonId] = s
+                            end
+                        end
+
+                        # taxonomic classification - taxon rank (required)
+                        if hTaxClass.has_key?('taxonomicRank')
+                            intTaxClass[:taxonRank] = hTaxClass['taxonomicRank']
+                        end
+                        if intTaxClass[:taxonRank].nil? || intTaxClass[:taxonRank] == ''
+                            responseObj[:readerExecutionMessages] << 'Taxonomic Classification attribute taxonomicRank is missing'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        # taxonomic classification - latin name (required)
+                        if hTaxClass.has_key?('latinName')
+                            intTaxClass[:taxonValue] = hTaxClass['latinName']
+                        end
+                        if intTaxClass[:taxonValue].nil? || intTaxClass[:taxonValue] == ''
+                            responseObj[:readerExecutionMessages] << 'Taxonomic Classification attribute latinName is missing'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        # taxonomic classification - common name []
+                        if hTaxClass.has_key?('commonName')
+                            hTaxClass['commonName'].each do |item|
+                                if item != ''
+                                    intTaxClass[:commonNames] << item
+                                end
+                            end
+                        end
+
+                         # taxonomic classification - taxonomic classification [taxonomicClassification]
+                        if hTaxClass.has_key?('subClassification')
+                            aItems = hTaxClass['subClassification']
+                            aItems.each do |item|
+                                hReturn = TaxonomicClassification.unpack(item, responseObj)
+                                unless hReturn.nil?
+                                    intTaxClass[:subClasses] << hReturn
+                                end
+                            end
+                        end
+
+                        return intTaxClass
+
+                    end
+
+                end
+
+            end
+        end
+    end
+end

data/lib/adiwg/mdtranslator/readers/mdJson/modules/module_taxonomicSystem.rb

@@ -0,0 +1,60 @@
+# unpack citation
+# Reader - ADIwg JSON to internal data structure
+
+# History:
+#   Stan Smith 2016-12-09 original script
+
+require_relative 'module_citation'
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+
+                module TaxonomicSystem
+
+                    def self.unpack(hSystem, responseObj)
+
+
+                        # return nil object if input is empty
+                        if hSystem.empty?
+                            responseObj[:readerExecutionMessages] << 'TaxonomicSystem object is empty'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        # instance classes needed in script
+                        intMetadataClass = InternalMetadata.new
+                        intSystem = intMetadataClass.newTaxonSystem
+
+                        # taxonomy system - citation (required) {CI_Citation}
+                        if hSystem.has_key?('citation')
+                            hCitation = hSystem['citation']
+                            hReturn = Citation.unpack(hCitation, responseObj)
+                            unless hReturn.nil?
+                                intSystem[:citation] = hReturn
+                            end
+                        end
+                        if intSystem[:citation].empty?
+                            responseObj[:readerExecutionMessages] << 'TaxonomicSystem object is missing citation'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        # taxonomy system - modifications
+                        if hSystem.has_key?('modifications')
+                            if hSystem['modifications'] != ''
+                                intSystem[:modifications] = hSystem['modifications']
+                            end
+                        end
+
+                        return intSystem
+
+                    end
+
+                end
+
+            end
+        end
+    end
+end

data/lib/adiwg/mdtranslator/readers/mdJson/modules/module_taxonomy.rb

@@ -0,0 +1,138 @@
+# unpack citation
+# Reader - ADIwg JSON to internal data structure
+
+# History:
+#   Stan Smith 2016-10-22 original script
+
+require_relative 'module_taxonomicSystem'
+require_relative 'module_identifier'
+require_relative 'module_responsibleParty'
+require_relative 'module_voucher'
+require_relative 'module_taxonomicClassification'
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+
+                module Taxonomy
+
+                    def self.unpack(hTaxonomy, responseObj)
+
+
+                        # return nil object if input is empty
+                        if hTaxonomy.empty?
+                            responseObj[:readerExecutionMessages] << 'Taxonomy object is empty'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        # instance classes needed in script
+                        intMetadataClass = InternalMetadata.new
+                        intTaxonomy = intMetadataClass.newTaxonomy
+
+                        # taxonomy - classification system [{TaxonomySystem}] (required)
+                        if hTaxonomy.has_key?('taxonomicSystem')
+                            aItems = hTaxonomy['taxonomicSystem']
+                            aItems.each do |item|
+                                hReturn = TaxonomicSystem.unpack(item, responseObj)
+                                unless hReturn.nil?
+                                    intTaxonomy[:taxonSystem] << hReturn
+                                end
+                            end
+                        end
+                        if intTaxonomy[:taxonSystem].empty?
+                            responseObj[:readerExecutionMessages] << 'Taxonomy object is missing taxonomicSystem object'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        # taxonomy - general taxonomic scope
+                        if hTaxonomy.has_key?('generalScope')
+                            if hTaxonomy['generalScope'] != ''
+                                intTaxonomy[:generalScope] = hTaxonomy['generalScope']
+                            end
+                        end
+
+                        # taxonomy - identification reference [{identifier}] (required)
+                        # this is required by ISO but relaxed for mdJson 2.0
+                        if hTaxonomy.has_key?('identificationReference')
+                            aItems = hTaxonomy['identificationReference']
+                            aItems.each do |hItem|
+                                unless hItem.empty?
+                                    hReturn = Identifier.unpack(hItem, responseObj)
+                                    unless hReturn.nil?
+                                        intTaxonomy[:idReferences] << hReturn
+                                    end
+                                end
+                            end
+                        end
+                        if intTaxonomy[:idReferences].empty?
+                            responseObj[:readerExecutionMessages] << 'Taxonomy object is missing identificationReference'
+                        end
+
+                        # taxonomy - observer [responsibleParty]
+                        if hTaxonomy.has_key?('observer')
+                            aItems = hTaxonomy['observer']
+                            aItems.each do |item|
+                                hReturn = ResponsibleParty.unpack(item, responseObj)
+                                unless hReturn.nil?
+                                    intTaxonomy[:observers] << hReturn
+                                end
+                            end
+                        end
+
+                        # taxonomy - identification procedure (required)
+                        if hTaxonomy.has_key?('identificationProcedure')
+                            if hTaxonomy['identificationProcedure'] != ''
+                                intTaxonomy[:idProcedure] = hTaxonomy['identificationProcedure']
+                            end
+                        end
+                        if intTaxonomy[:idProcedure].nil? || intTaxonomy[:idProcedure] == ''
+                            responseObj[:readerExecutionMessages] << 'Taxonomy object is missing identificationProcedure'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        # taxonomy - identification completeness
+                        if hTaxonomy.has_key?('identificationCompleteness')
+                            if hTaxonomy['identificationCompleteness'] != ''
+                                intTaxonomy[:idCompleteness] = hTaxonomy['identificationCompleteness']
+                            end
+                        end
+
+                        # taxonomy - voucher []
+                        if hTaxonomy.has_key?('voucher')
+                            aItems = hTaxonomy['voucher']
+                            aItems.each do |item|
+                                hReturn = Voucher.unpack(item, responseObj)
+                                unless hReturn.nil?
+                                    intTaxonomy[:vouchers] << hReturn
+                                end
+                            end
+                        end
+
+                        # taxonomy - taxonomic classification {taxonomicClassification} (required)
+                        if hTaxonomy.has_key?('taxonomicClassification')
+                        item = hTaxonomy['taxonomicClassification']
+                            hReturn = TaxonomicClassification.unpack(item, responseObj)
+                            unless hReturn.nil?
+                                intTaxonomy[:taxonClass] = hReturn
+                            end
+                        end
+                        if intTaxonomy[:taxonClass].empty?
+                            responseObj[:readerExecutionMessages] << 'Taxonomy object is missing taxonomicClassification'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        return intTaxonomy
+
+                    end
+
+                end
+
+            end
+        end
+    end
+end

data/lib/adiwg/mdtranslator/readers/mdJson/modules/module_temporalExtent.rb

@@ -0,0 +1,70 @@
+# unpack temporal extent
+# Reader - ADIwg JSON to internal data structure
+
+# History:
+# 	Stan Smith 2016-10-24 original script
+
+require_relative 'module_timeInstant'
+require_relative 'module_timePeriod'
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+
+                module TemporalExtent
+
+                    def self.unpack(hTemporal, responseObj)
+
+                        # return nil object if input is empty
+                        if hTemporal.empty?
+                            responseObj[:readerExecutionMessages] << 'Temporal Extent object is empty'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        # instance classes needed in script
+                        intMetadataClass = InternalMetadata.new
+                        intTemporal = intMetadataClass.newTemporalExtent
+                        haveOne = false
+
+                        # temporal extent - time instant (required if not others)
+                        if hTemporal.has_key?('timeInstant')
+                            hTime = hTemporal['timeInstant']
+                            unless hTime.empty?
+                                hObject = TimeInstant.unpack(hTime, responseObj)
+                                unless hObject.nil?
+                                    intTemporal[:timeInstant] = hObject
+                                    haveOne = true
+                                end
+                            end
+                        end
+
+                        # temporal extent - time period (required if not others)
+                        if hTemporal.has_key?('timePeriod')
+                            hTime = hTemporal['timePeriod']
+                            unless hTime.empty?
+                                hObject = TimePeriod.unpack(hTime, responseObj)
+                                unless hObject.nil?
+                                    intTemporal[:timePeriod] = hObject
+                                    haveOne = true
+                                end
+                            end
+                        end
+
+                        unless haveOne
+                            responseObj[:readerExecutionMessages] << 'Temporal Extent did not have an object of supported type'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        return intTemporal
+
+                    end
+
+                end
+
+            end
+        end
+    end
+end

data/lib/adiwg/mdtranslator/readers/mdJson/modules/module_timeInstant.rb

@@ -0,0 +1,87 @@
+# unpack time instant
+# Reader - ADIwg JSON to internal data structure
+
+# History:
+# 	Stan Smith 2016-10-24 original script
+
+require_relative 'module_identifier'
+require_relative 'module_dateTime'
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+
+                module TimeInstant
+
+                    def self.unpack(hInstant, responseObj)
+
+                        # return nil object if input is empty
+                        if hInstant.empty?
+                            responseObj[:readerExecutionMessages] << 'Time Instant object is empty'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        # instance classes needed in script
+                        intMetadataClass = InternalMetadata.new
+                        intInstant = intMetadataClass.newTimeInstant
+
+                        # time instant - id
+                        if hInstant.has_key?('id')
+                            if hInstant['id'] != ''
+                                intInstant[:timeId] = hInstant['id']
+                            end
+                        end
+
+                        # time instant - description
+                        if hInstant.has_key?('description')
+                            if hInstant['description'] != ''
+                                intInstant[:description] = hInstant['description']
+                            end
+                        end
+
+                        # time instant - identifier {Identifier}
+                        if hInstant.has_key?('identifier')
+                            unless hInstant['identifier'].empty?
+                                hReturn = Identifier.unpack(hInstant['identifier'], responseObj)
+                                unless hReturn.nil?
+                                    intInstant[:identifier] = hReturn
+                                end
+                            end
+                        end
+
+                        # time instant - instant names []
+                        if hInstant.has_key?('instantName')
+                            hInstant['instantName'].each do |item|
+                                if item != ''
+                                    intInstant[:instantNames] << item
+                                end
+                            end
+                        end
+
+                        # time instant - datetime
+                        if hInstant.has_key?('dateTime')
+                            if hInstant['dateTime'] != ''
+                                hDate = DateTime.unpack(hInstant['dateTime'], responseObj)
+                                unless hDate.nil?
+                                    intInstant[:timeInstant] = hDate
+                                end
+                            end
+                        end
+                        if intInstant[:timeInstant].empty?
+                            responseObj[:readerExecutionMessages] << 'Time Instant is missing dateTime'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        return intInstant
+
+                    end
+
+                end
+
+            end
+        end
+    end
+end

data/lib/adiwg/mdtranslator/readers/mdJson/modules/module_timeInterval.rb

@@ -0,0 +1,69 @@
+# unpack time interval
+# Reader - ADIwg JSON to internal data structure
+
+# History:
+# 	Stan Smith 2016-10-14 original script
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+
+                module TimeInterval
+
+                    def self.unpack(hTimeInt, responseObj)
+
+                        # return nil object if input is empty
+                        if hTimeInt.empty?
+                            responseObj[:readerExecutionMessages] << 'Time Interval object is empty'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        # instance classes needed in script
+                        intMetadataClass = InternalMetadata.new
+                        intTime = intMetadataClass.newTimeInterval
+
+                        # time interval - interval (required)
+                        if hTimeInt.has_key?('interval')
+                            interval = hTimeInt['interval']
+                            if interval != ''
+                                if interval.is_a?(Integer) || interval.is_a?(Float)
+                                    intTime[:interval] = hTimeInt['interval']
+                                else
+                                    responseObj[:readerExecutionMessages] << 'Time Interval attribute interval is not a number'
+                                    responseObj[:readerExecutionPass] = false
+                                    return nil
+                                end
+                            end
+                        end
+                        if intTime[:interval].nil? || intTime[:interval] == ''
+                            responseObj[:readerExecutionMessages] << 'Time Interval attribute interval is missing'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        # time interval - units (required) {enum}
+                        if hTimeInt.has_key?('units')
+                            units = hTimeInt['units']
+                            unless units.nil?
+                                if %w{year month day hour minute second}.one? {|word| word == units}
+                                    intTime[:units] = hTimeInt['units']
+                                end
+                            end
+                        end
+                        if intTime[:units].nil? || intTime[:units] == ''
+                            responseObj[:readerExecutionMessages] << 'Time Interval attribute units is missing or invalid'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        return intTime
+                    end
+
+                end
+
+            end
+        end
+    end
+end

data/lib/adiwg/mdtranslator/readers/mdJson/modules/module_timePeriod.rb

@@ -0,0 +1,120 @@
+# unpack time interval
+# Reader - ADIwg JSON to internal data structure
+
+# History:
+# 	Stan Smith 2016-10-14 original script
+
+require_relative 'module_dateTime'
+require_relative 'module_identifier'
+require_relative 'module_timeInterval'
+require_relative 'module_duration'
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+
+                module TimePeriod
+
+                    def self.unpack(hTimePeriod, responseObj)
+
+                        # return nil object if input is empty
+                        if hTimePeriod.empty?
+                            responseObj[:readerExecutionMessages] << 'Time Period object is empty'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        # instance classes needed in script
+                        intMetadataClass = InternalMetadata.new
+                        intTimePer = intMetadataClass.newTimePeriod
+
+                        # time period - id
+                        if hTimePeriod.has_key?('id')
+                            if hTimePeriod['id'] != ''
+                                intTimePer[:timeId] = hTimePeriod['id']
+                            end
+                        end
+
+                        # time period - description
+                        if hTimePeriod.has_key?('description')
+                            if hTimePeriod['description'] != ''
+                                intTimePer[:description] = hTimePeriod['description']
+                            end
+                        end
+
+                        # time period - identifier {Identifier}
+                        if hTimePeriod.has_key?('identifier')
+                            unless hTimePeriod['identifier'].empty?
+                                hReturn = Identifier.unpack(hTimePeriod['identifier'], responseObj)
+                                unless hReturn.nil?
+                                    intTimePer[:identifier] = hReturn
+                                end
+                            end
+                        end
+
+                        # time period - period names []
+                        if hTimePeriod.has_key?('periodName')
+                            hTimePeriod['periodName'].each do |item|
+                                if item != ''
+                                    intTimePer[:periodNames] << item
+                                end
+                            end
+                        end
+
+                        # time period - start datetime
+                        if hTimePeriod.has_key?('startDateTime')
+                            if hTimePeriod['startDateTime'] != ''
+                                hReturn = DateTime.unpack(hTimePeriod['startDateTime'], responseObj)
+                                unless hReturn.nil?
+                                    intTimePer[:startDateTime] = hReturn
+                                end
+                            end
+                        end
+
+                        # time period - end datetime
+                        if hTimePeriod.has_key?('endDateTime')
+                            if hTimePeriod['endDateTime'] != ''
+                                hReturn = DateTime.unpack(hTimePeriod['endDateTime'], responseObj)
+                                unless hReturn.nil?
+                                    intTimePer[:endDateTime] = hReturn
+                                end
+                            end
+                        end
+
+                        if intTimePer[:startDateTime].empty? && intTimePer[:endDateTime].empty?
+                            responseObj[:readerExecutionMessages] << 'Time Period is missing both a start and an end time'
+                            responseObj[:readerExecutionPass] = false
+                            return nil
+                        end
+
+                        # time period - time interval
+                        if hTimePeriod.has_key?('timeInterval')
+                            unless hTimePeriod['timeInterval'].empty?
+                                hReturn = TimeInterval.unpack(hTimePeriod['timeInterval'], responseObj)
+                                unless hReturn.nil?
+                                    intTimePer[:timeInterval] = hReturn
+                                end
+                            end
+                        end
+
+                        # time period - time duration
+                        if hTimePeriod.has_key?('duration')
+                            unless hTimePeriod['duration'].empty?
+                                hReturn = Duration.unpack(hTimePeriod['duration'], responseObj)
+                                unless hReturn.nil?
+                                    intTimePer[:duration] = hReturn
+                                end
+                            end
+                        end
+
+                        return intTimePer
+
+                    end
+
+                end
+
+            end
+        end
+    end
+end