adiwg-mdtranslator 2.20.0.pre.beta.10 → 2.21.0.pre.beta.0

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

@@ -0,0 +1,73 @@
+require_relative 'module_citation'
+require_relative 'module_platform'
+require_relative 'module_instrumentationEventList'
+require_relative 'module_identifier'
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+  
+                module Instrument
+                    def self.unpack(hInstrument, responseObj, inContext = nil)
+
+                        @MessagePath = ADIWG::Mdtranslator::Readers::MdJson::MdJson
+
+                        intMetadataClass = InternalMetadata.new
+                        intInstrument = intMetadataClass.newInstrument
+
+                        outContext = 'instrument'
+                        outContext = inContext + ' > ' + outContext unless inContext.nil?
+
+                        if hInstrument.has_key?('instrumentId')
+                            intInstrument[:instrumentId] = hInstrument['instrumentId']
+                        else
+                            @MessagePath.issueWarning(40, responseObj, outContext)
+                        end
+
+                        if hInstrument.has_key?('citation')
+                            intInstrument[:citation] = Citation.unpack(hInstrument['citation'], responseObj, outContext)
+                        end
+
+                        if hInstrument.has_key?('identifier')
+                            intInstrument[:identifier] = Identifier.unpack(hInstrument['identifier'], responseObj, outContext)
+                        else
+                            @MessagePath.issueWarning(40, responseObj, outContext)
+                        end
+
+                        if hInstrument.has_key?('instrumentType')
+                            intInstrument[:instrumentType] = hInstrument['instrumentType']
+                        else
+                            @MessagePath.issueWarning(40, responseObj, outContext)
+                        end
+
+                        if hInstrument.has_key?('description')
+                            intInstrument[:description] = hInstrument['description']
+                        end
+
+                        if hInstrument.has_key?('mountedOn')
+                            intInstrument[:mountedOn] = Platform.unpack(hInstrument['mountedOn'], responseObj, outContext)
+                        end
+
+                        if hInstrument.has_key?('history')
+                            hInstrument['history'].each do |item|
+                                hReturn = InstrumentationEventList.unpack(item, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intInstrument[:histories] << hReturn
+                                end
+                            end
+                        end
+
+                        if hInstrument.has_key?('hostId')
+                            intInstrument[:hostId] = Identifier.unpack(hInstrument['hostId'], responseObj, outContext)
+                        end
+
+                        intInstrument
+
+                    end
+                end
+
+            end
+        end
+    end
+end

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

@@ -0,0 +1,77 @@
+require_relative 'module_citation'
+require_relative 'module_extent'
+require_relative 'module_revision'
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+  
+                module InstrumentationEvent
+                    def self.unpack(hInstrumentationEvent, responseObj, inContext = nil)
+                        @MessagePath = ADIWG::Mdtranslator::Readers::MdJson::MdJson
+
+                        intMetadataClass = InternalMetadata.new
+                        intInstrumentationEvent = intMetadataClass.newInstrumentationEvent
+
+                        outContext = 'instrumentation event'
+                        outContext = inContext + ' > ' + outContext unless inContext.nil?
+
+                        eventTypeArray = [
+                            "announcement",
+                            "calibration",
+                            "calibrationCoefficientUpdate",
+                            "dataLoss",
+                            "fatal",
+                            "manoeuvre",
+                            "missingData",
+                            "notice",
+                            "prelaunch",
+                            "severe",
+                            "switchOff",
+                            "switchOn",
+                            "clean"
+                        ]
+
+                        if hInstrumentationEvent.has_key?('citation')
+                            hInstrumentationEvent['citation'].each do |citation|
+                                hReturn = Citation.unpack(citation, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intInstrumentationEvent[:citations] << hReturn
+                                end
+                            end
+                        end
+
+                        if hInstrumentationEvent.has_key?('description')
+                            intInstrumentationEvent[:description] = hInstrumentationEvent['description']
+                        else
+                            @MessagePath.issueWarning(40, responseObj, outContext)
+                        end
+
+                        if hInstrumentationEvent.has_key?('extent')
+                            intInstrumentationEvent[:extent] = Extent.unpack(hInstrumentationEvent['extent'], responseObj, outContext)
+                        end
+
+                        if hInstrumentationEvent.has_key?('eventType') && eventTypeArray.include?(hInstrumentationEvent['eventType'])
+                            intInstrumentationEvent[:eventType] = hInstrumentationEvent['eventType']
+                        else
+                            @MessagePath.issueWarning(41, responseObj, outContext)
+                        end
+
+                        if hInstrumentationEvent.has_key?('revisionHistory')
+                            hInstrumentationEvent['revisionHistory'].each do |item|
+                                hReturn = Revision.unpack(item, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intInstrumentationEvent[:revisionHistories] << hReturn
+                                end
+                            end
+                        end
+
+                        intInstrumentationEvent
+                    end
+                end
+
+            end
+        end
+    end
+end

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

@@ -0,0 +1,62 @@
+require_relative 'module_citation'
+require_relative 'module_locale'
+require_relative 'module_constraint'
+require_relative 'module_instrumentationEvent'
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+  
+                module InstrumentationEventList
+                    def self.unpack(hInstrumentationEventList, responseObj, inContext = nil)
+                        @MessagePath = ADIWG::Mdtranslator::Readers::MdJson::MdJson
+
+                        intMetadataClass = InternalMetadata.new
+                        intInstrumentationEventList = intMetadataClass.newInstrumentationEventList
+
+                        outContext = 'instrumentation event list'
+                        outContext = inContext + ' > ' + outContext unless inContext.nil?
+
+                        if hInstrumentationEventList.has_key?('citation')
+                            intInstrumentationEventList[:citation] = Citation.unpack(hInstrumentationEventList['citation'], responseObj, outContext)
+                        end
+
+                        if hInstrumentationEventList.has_key?('description')
+                            intInstrumentationEventList[:description] = hInstrumentationEventList['description']
+                        else
+                            @MessagePath.issueWarning(40, responseObj, outContext, 'instrumentation event description')
+                        end
+
+                        if hInstrumentationEventList.has_key?('locale')
+                            hReturn = Locale.unpack(hInstrumentationEventList['locale'], responseObj, outContext)
+                            
+                        end
+
+                        if hInstrumentationEventList.has_key?('constraint')
+                            constraints = hInstrumentationEventList['constraint']
+                            constraints.each do |constraint|
+                                hReturn = Constraint.unpack(hInstrumentationEventList['constraint'], responseObj, outContext)
+                                unless hReturn.nil?
+                                    intInstrumentationEventList[:constraints] << hReturn
+                                end
+                            end
+                        end
+
+                        if hInstrumentationEventList.has_key?('instrumentationEvent')
+                            hInstrumentationEventList['instrumentationEvent'].each do |item|
+                                hReturn = InstrumentationEvent.unpack(item, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intInstrumentationEventList[:instrumentationEvents] << hReturn
+                                end
+                            end
+                        end
+
+                        intInstrumentationEventList
+                    end
+                end
+
+            end
+        end
+    end
+end

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

@@ -13,6 +13,7 @@ require_relative 'module_associatedResource'
 require_relative 'module_additionalDocumentation'
 require_relative 'module_funding'
 require_relative 'module_dataQuality'
+require_relative 'module_acquisition'
 
 module ADIWG
    module Mdtranslator
@@ -128,6 +129,16 @@ module ADIWG
                      end
                   end
 
+                  if hMetadata.has_key?('acquisition')
+                     aItems = hMetadata['acquisition']
+                     aItems.each do |item|
+                        hReturn = Acquisition.unpack(item, responseObj)
+                        unless hReturn.nil?
+                           intMetadata[:acquisitions] << hReturn
+                        end
+                     end
+                  end
+
                   return intMetadata
 
                end

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

@@ -0,0 +1,104 @@
+require 'adiwg/mdtranslator/internal/module_codelistFun'
+require_relative 'module_identifier'
+require_relative 'module_extent'
+require_relative 'module_event'
+require_relative 'module_pass'
+require_relative 'module_instrument'
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+  
+                module Objective
+                    def self.unpack(hObjective, responseObj, inContext = nil)
+
+                        @MessagePath = ADIWG::Mdtranslator::Readers::MdJson::MdJson
+
+                        intMetadataClass = InternalMetadata.new
+                        intObjective = intMetadataClass.newObjective
+
+                        outContext = 'objective'
+                        outContext = inContext + ' > ' + outContext unless inContext.nil?
+
+                        if hObjective.has_key?('objectiveId')
+                            intObjective[:objectiveId] = hObjective['objectiveId']
+                        else
+                            @MessagePath.issueError(200, responseObj, outContext)
+                        end
+
+                        if hObjective.has_key?('identifier')
+                            aItems = hObjective['identifier']
+                            aItems.each do |item|
+                                hReturn = Identifier.unpack(item, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intObjective[:identifiers] << hReturn
+                                end
+                            end
+                        else
+                            @MessagePath.issueError(201, responseObj, outContext)
+                        end
+
+                        if hObjective.has_key?('priority')
+                            intObjective[:priority] = hObjective['priority']
+                        end
+
+                        if hObjective.has_key?('objectiveType')
+                            aItems = hObjective['objectiveType']
+                            aItems.each do |item|
+                                if CodelistFun.validateItem('iso_objectiveTypeCode', item)
+                                    intObjective[:objectiveTypes] << item
+                                end
+                            end
+                        end
+
+                        if hObjective.has_key?('function')
+                            hObjective['function'].each do |item|
+                                intObjective[:functions] << item
+                            end
+                        end
+
+                        if hObjective.has_key?('extent')
+                            hObjective['extent'].each do |item|
+                                hReturn = Extent.unpack(item, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intObjective[:extents] << hReturn
+                                end
+                            end
+                        end
+
+                        if hObjective.has_key?('objectiveOccurrence')
+                            hObjective['objectiveOccurrence'].each do |item|
+                                hReturn = Event.unpack(item, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intObjective[:occurrences] << hReturn
+                                end
+                            end
+                        end
+
+                        if hObjective.has_key?('pass')
+                            hObjective['pass'].each do |item|
+                                hReturn = Pass.unpack(item, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intObjective[:passes] << hReturn
+                                end
+                            end
+                        end
+
+                        if hObjective.has_key?('sensingInstrument')
+                            hObjective['sensingInstrument'].each do |item|
+                                hReturn = Instrument.unpack(item, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intObjective[:sensingInstruments] << hReturn
+                                end
+                            end
+                        end
+
+                        intObjective
+                    end
+                end
+
+            end
+        end
+    end
+end

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

@@ -0,0 +1,119 @@
+require 'adiwg/mdtranslator/internal/module_codelistFun'
+require_relative 'module_citation'
+require_relative 'module_identifier'
+require_relative 'module_objective'
+require_relative 'module_platform'
+require_relative 'module_event'
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+  
+                module Operation
+                    def self.unpack(hOperation, responseObj, inContext = nil)
+                        
+                        @MessagePath = ADIWG::Mdtranslator::Readers::MdJson::MdJson
+
+                        intMetadataClass = InternalMetadata.new
+                        intOperation = intMetadataClass.newOperation
+
+                        outContext = 'operation'
+                        outContext = inContext + ' > ' + outContext unless inContext.nil?
+
+                        if hOperation.has_key?('operationId')
+                            intOperation[:operationId] = hOperation['operationId']
+                            
+                        else
+                            @MessagePath.issueError(42, responseObj, outContext)
+                        end
+
+                        if hOperation.has_key?('description')
+                            intOperation[:description] = hOperation['description']
+                        end
+
+                        if hOperation.has_key?('citation')
+                            hReturn = Citation.unpack(hOperation['citation'], responseObj, outContext)
+                            unless hReturn.nil?
+                                intOperation[:citation] = hReturn
+                            end
+                        end
+
+                        if hOperation.has_key?('identifier')
+                            hReturn = Identifier.unpack(hOperation['identifier'], responseObj, outContext)
+                            unless hReturn.nil?
+                                intOperation[:identifier] = hReturn
+                            end
+                        else
+                            @MessagePath.issueError(44, responseObj, outContext)
+                        end
+
+                        if hOperation.has_key?('status') && CodelistFun.validateItem('iso_progress', hOperation['status'])
+                            intOperation[:status] = hOperation['status']
+                        end
+
+                        if hOperation.has_key?('operationType') && CodelistFun.validateItem('iso_operationTypeCode', hOperation['operationType'])
+                            intOperation[:operationType] = hOperation['operationType']
+                        end
+
+                        if hOperation.has_key?('objective')
+                            hOperation['objective'].each do |item|
+                                hReturn = Objective.unpack(item, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intOperation[:objectives] << hReturn
+                                end
+                            end
+                        end
+
+                        if hOperation.has_key?('parentOperation')
+                            hReturn = Operation.unpack(hOperation['parentOperation'], responseObj, outContext)
+                            unless hReturn.nil?
+                                intOperation[:parentOperation] = hReturn
+                            end
+                        else
+                            @MessagePath.issueError(44, responseObj, outContext)
+                        end
+
+                        if hOperation.has_key?('childOperation')
+                            hOperation['childOperation'].each do |item|
+                                hReturn = Operation.unpack(item, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intOperation[:childOperations] << hReturn
+                                end
+                            end
+                        end
+
+                        if hOperation.has_key?('plan')
+                            hReturn = Plan.unpack(hOperation['plan'], responseObj, outContext)
+                            unless hReturn.nil?
+                                intOperation[:plan] = hReturn
+                            end
+                        end
+
+                        if hOperation.has_key?('platform')
+                            hOperation['platform'].each do |item|
+                                hReturn = Platform.unpack(item, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intOperation[:platforms] << hReturn
+                                end
+                            end
+                        end
+
+                        if hOperation.has_key?('significantEvent')
+                            hOperation['significantEvent'].each do |item|
+                                hReturn = Event.unpack(item, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intOperation[:significantEvents] << hReturn
+                                end
+                            end
+                        end
+
+                        intOperation
+
+                    end
+                end
+
+            end
+        end
+    end
+end

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

@@ -0,0 +1,53 @@
+require_relative 'module_identifier'
+require_relative 'module_extent'
+require_relative 'module_event'
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+  
+                module Pass
+                    def self.unpack(hPass, responseObj, inContext = nil)
+                        @MessagePath = ADIWG::Mdtranslator::Readers::MdJson::MdJson
+
+                        intMetadataClass = InternalMetadata.new
+                        intPass = intMetadataClass.newPass
+
+                        outContext = 'pass'
+                        outContext = inContext + ' > ' + outContext unless inContext.nil?
+
+                        if hPass.has_key?('passId')
+                            intPass[:passId] = hPass['passId']
+                        else
+                            @MessagePath.issueWarning(40, responseObj, outContext)
+                        end
+
+                        if hPass.has_key?('identifier')
+                            intPass[:identifier] = Identifier.unpack(hPass['identifier'], responseObj, outContext)
+                        else
+                            @MessagePath.issueWarning(40, responseObj, outContext)
+                        end
+
+                        if hPass.has_key?('extent')
+                            intPass[:extent] = Extent.unpack(hPass['extent'], responseObj, outContext)
+                        end
+
+                        if hPass.has_key?('relatedEvent')
+                            hPass['relatedEvent'].each do |item|
+                                hReturn = Event.unpack(item, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intPass[:relatedEvents] << hReturn
+                                end
+                            end
+                        end
+
+                        intPass
+
+                    end
+                end
+
+            end
+        end
+    end
+end

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

@@ -0,0 +1,80 @@
+require 'adiwg/mdtranslator/internal/module_codelistFun'
+require_relative 'module_citation'
+require_relative 'module_operation'
+require_relative 'module_requirement'
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+  
+                module Plan
+                    def self.unpack(hPlan, responseObj, inContext = nil)
+                        
+                        @MessagePath = ADIWG::Mdtranslator::Readers::MdJson::MdJson
+
+                        # return nil object if input is empty
+                        if hPlan.empty?
+                            @MessagePath.issueWarning(40, responseObj, inContext)
+                            return nil
+                        end
+
+                        intMetadataClass = InternalMetadata.new
+                        intPlan = intMetadataClass.newPlan
+
+                        outContext = 'plan'
+                        outContext = inContext + ' > ' + outContext unless inContext.nil?
+
+                        if hPlan.has_key?('planId')
+                            intPlan[:planId] = hPlan['planId']
+                            
+                        else
+                            @MessagePath.issueError(42, responseObj, outContext)
+                        end
+
+                        if hPlan.has_key?('planType') && CodelistFun.validateItem('iso_geometryTypeCode', hPlan['planType'])
+                            intPlan[:planType] = hPlan['planType']
+                        end
+
+                        if hPlan.has_key?('status') && CodelistFun.validateItem('iso_progress', hPlan['status'])
+                            intPlan[:status] = hPlan['status']
+                        else
+                            @MessagePath.issueError(43, responseObj, outContext)
+                        end
+
+                        if hPlan.has_key?('citation')
+                            hReturn = Citation.unpack(hPlan['citation'], responseObj, outContext)
+                            unless hReturn.nil?
+                                intPlan[:citation] = hReturn
+                            end
+                        else
+                            @MessagePath.issueError(44, responseObj, outContext)
+                        end
+
+                        if hPlan.has_key?('planOperation')
+                            hPlan['planOperation'].each do |item|
+                                hReturn = Operation.unpack(item, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intPlan[:planOperations] << hReturn
+                                end
+                            end                            
+                        end
+
+                        if hPlan.has_key?('satisfiedRequirement')
+                            hPlan['satisfiedRequirement'].each do |item|
+                                hReturn = Requirement.unpack(item, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intPlan[:satisfiedRequirements] << hReturn
+                                end
+                            end
+                        end
+
+                        intPlan
+
+                    end
+                end
+
+            end
+        end
+    end
+end