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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 673fe90b50664af5833748a5fda2bebc8673e4ddeef1a2178d910edbabd93428
-  data.tar.gz: e8a7c9a20ffc9d05a6eddaef3a8f17ff466120d467511f95030689d0526449ae
+  metadata.gz: b6d6f205260d7cd279df45c873810e05a328d4fd8915be617b29c4c57044af13
+  data.tar.gz: fcfc19da4c41bc3b93b528f57122119cc12d8f988e3afc9553f4275f639cd833
 SHA512:
-  metadata.gz: 02bebf2b017b6a5f521a33e65a538d35ea7fc50a004abe6cc01672127aa6919846b0abc55de9ba812e1aab94c5f29291e780b9fd0272f4b7de9de93b99751910
-  data.tar.gz: bd92dc9a82ff2974b0b7543dea038401c902f970f35d43775776c6509edb662dccd5cfa52f6dddaa373e92af233f0b24ae1683ee91c82dc9933b32cd90a1509b
+  metadata.gz: '097c2bf2ffdcfc10e63b16d44cdf72fc9e30c0cdebeab4366e07eae6d0c13dc52b782c3882d17516c8843cb19e7cecc2c064aa8e89dd56cbeccb254acae4e8f1'
+  data.tar.gz: 14fab38df050287ba08b0337aeaf9ebc4c2e42a113a63709cff0019f7dc3ba761534c35586e055aef57b5b147cfb4571eb466cd5a208f90da431aa3e09742309

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    adiwg-mdtranslator (2.20.0.pre.beta.10)
+    adiwg-mdtranslator (2.21.0.pre.beta.1)
       adiwg-mdcodes (= 2.10.1)
       adiwg-mdjson_schemas (= 2.10.1)
       builder (~> 3.2)

data/lib/adiwg/mdtranslator/internal/internal_metadata_obj.rb

@@ -143,7 +143,8 @@ class InternalMetadata
          associatedResources: [],
          additionalDocuments: [],
          funding: [],
-         dataQuality: []
+         dataQuality: [],
+         acquisitions: []
       }
    end
 
@@ -158,6 +159,7 @@ class InternalMetadata
    # acquisition ----------------------------
    def newAcquisition
       {
+         scope: {},
          plans: [],
          requirements: [],
          objectives: [],
@@ -175,19 +177,23 @@ class InternalMetadata
          averageAirTemperature: nil,
          maxRelativeHumidity: nil,
          maxAltitude: nil,
-         meteorologicalConditions: nil
+         meteorologicalConditions: nil,
+         solarAzimuth: nil,
+         solarElevation: nil
+         
       }
    end
 
    def newEvent
       {
          eventId: nil,
+         identifier: {},
          trigger: nil,
          context: nil,
          sequence: nil,
          dateTime: nil,
          expectedObjectives: [],
-         relatedPass: nil,
+         relatedPass: {},
          relatedSensors: []
       }
    end
@@ -199,7 +205,29 @@ class InternalMetadata
          identifier: {},
          instrumentType: nil,
          description: nil,
-         mountedOn: nil
+         mountedOn: {},
+         histories: [],
+         hostId: {}
+      }
+   end
+
+   def newInstrumentationEvent
+      {
+         citations: [],
+         description: nil,
+         extent: {},
+         eventType: nil,
+         revisionHistories: [],
+      }
+   end
+
+   def newInstrumentationEventList
+      {
+         citation: {},
+         description: nil,
+         locale: {},
+         constraints: [],
+         instrumentationEvents: []
       }
    end
 
@@ -240,14 +268,15 @@ class InternalMetadata
    def newOperation
       {
          operationId: nil,
+         description: nil,
          citation: {},
          identifier: {},
          status: nil,
          operationType: nil,
          objectives: [],
-         parentOperations: nil,
+         parentOperation: {},
          childOperations: [],
-         plan: nil,
+         plan: {},
          platforms: [],
          significantEvents: []
       }
@@ -267,6 +296,14 @@ class InternalMetadata
       }
    end
 
+   def newRevision
+      {
+         description: nil,
+         responsibleParty: {},
+         dateInfo: []
+      }
+   end
+
    def newPlatform
       {
          platformId: nil,
@@ -274,7 +311,8 @@ class InternalMetadata
          identifier: {},
          description: nil,
          sponsors: [],
-         instruments: []
+         instruments: [],
+         history: []
       }
    end
 
@@ -541,6 +579,7 @@ class InternalMetadata
    # data dictionary ------------------------
    def newDataDictionary
       {
+         dictionaryId: nil,
          description: nil,
          subjects: [],
          citation: {},

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

@@ -0,0 +1,133 @@
+require_relative 'module_scope'
+require_relative 'module_objective'
+require_relative 'module_requirement'
+require_relative 'module_platform'
+require_relative 'module_instrument'
+require_relative 'module_operation'
+require_relative 'module_pass'
+require_relative 'module_event'
+require_relative 'module_environment'
+require_relative 'module_plan'
+
+module ADIWG
+   module Mdtranslator
+      module Readers
+         module MdJson
+ 
+            module Acquisition
+ 
+               def self.unpack(hAcquisition, responseObj, inContext = nil)
+ 
+                  @MessagePath = ADIWG::Mdtranslator::Readers::MdJson::MdJson
+
+                  outContext = 'acquisition'
+                  outContext = inContext + ' > ' + outContext unless inContext.nil?
+
+                  # instance classes needed in script
+                  intMetadataClass = InternalMetadata.new
+                  intAcquisition = intMetadataClass.newAcquisition
+ 
+                  if hAcquisition.has_key?('scope')
+                     unless hAcquisition['scope'].empty?
+                        hReturn = Scope.unpack(hAcquisition['scope'], responseObj, outContext)
+                        unless hReturn.nil?
+                           intAcquisition[:scope] = hReturn
+                        end
+                     end
+                  end
+
+                  if hAcquisition.has_key?('plan')
+                     aItems = hAcquisition['plan']
+                     aItems.each do |item|
+                        hReturn = Plan.unpack(item, responseObj, outContext)
+                        unless hReturn.nil?
+                           intAcquisition[:plans] << hReturn
+                        end
+                     end
+                  end
+
+                  if hAcquisition.has_key?('requirement')
+                     aItems = hAcquisition['requirement']
+                     aItems.each do |item|
+                        hReturn = Requirement.unpack(item, responseObj, outContext)
+                        unless hReturn.nil?
+                           intAcquisition[:requirements] << hReturn
+                        end
+                     end
+                  end
+
+                  if hAcquisition.has_key?('objective')
+                     aItems = hAcquisition['objective']
+                     aItems.each do |item|
+                        hReturn = Objective.unpack(item, responseObj, outContext)
+                        unless hReturn.nil?
+                           intAcquisition[:objectives] << hReturn
+                        end
+                     end
+                  end
+
+                  if hAcquisition.has_key?('platform')
+                     aItems = hAcquisition['platform']
+                     aItems.each do |item|
+                        hReturn = Platform.unpack(item, responseObj, outContext)
+                        unless hReturn.nil?
+                           intAcquisition[:platforms] << hReturn
+                        end
+                     end
+                  end
+
+                  if hAcquisition.has_key?('instrument')
+                     aItems = hAcquisition['instrument']
+                     aItems.each do |item|
+                        hReturn = Instrument.unpack(item, responseObj, outContext)
+                        unless hReturn.nil?
+                           intAcquisition[:instruments] << hReturn
+                        end
+                     end
+                  end
+
+                  if hAcquisition.has_key?('operation')
+                     aItems = hAcquisition['operation']
+                     aItems.each do |item|
+                        hReturn = Operation.unpack(item, responseObj, outContext)
+                        unless hReturn.nil?
+                           intAcquisition[:operations] << hReturn
+                        end
+                     end
+                  end
+
+                  if hAcquisition.has_key?('event')
+                     aItems = hAcquisition['event']
+                     aItems.each do |item|
+                        hReturn = Event.unpack(item, responseObj, outContext)
+                        unless hReturn.nil?
+                           intAcquisition[:events] << hReturn
+                        end
+                     end
+                  end
+
+                  if hAcquisition.has_key?('pass')
+                     aItems = hAcquisition['pass']
+                     aItems.each do |item|
+                        hReturn = Pass.unpack(item, responseObj, outContext)
+                        unless hReturn.nil?
+                           intAcquisition[:passes] << hReturn
+                        end
+                     end
+                  end
+                  
+                  if hAcquisition.has_key?('environment')
+                     intAcquisition[:environment] = Environment.unpack(hAcquisition['environment'], responseObj, outContext)
+                  end
+                  
+                  return intAcquisition
+
+               end
+
+            end
+ 
+         end
+      end
+   end
+end
+ 

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

@@ -0,0 +1,47 @@
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+  
+                module Environment
+                    def self.unpack(hEnvironment, responseObj, inContext = nil)
+
+                        intMetadataClass = InternalMetadata.new
+                        intEnvironment = intMetadataClass.newEnvironment
+
+                        outContext = 'environment'
+                        outContext = inContext + ' > ' + outContext unless inContext.nil?
+
+                        if hEnvironment.has_key?('averageAirTemperature')
+                            intEnvironment[:averageAirTemperature] = hEnvironment['averageAirTemperature']
+                        end
+
+                        if hEnvironment.has_key?('maxRelativeHumidity')
+                            intEnvironment[:maxRelativeHumidity] = hEnvironment['maxRelativeHumidity']
+                        end
+
+                        if hEnvironment.has_key?('maxAltitude')
+                            intEnvironment[:maxAltitude] = hEnvironment['maxAltitude']
+                        end
+
+                        if hEnvironment.has_key?('meteorologicalConditions')
+                            intEnvironment[:meteorologicalConditions] = hEnvironment['meteorologicalConditions']
+                        end
+
+                        if hEnvironment.has_key?('solarAzimuth')
+                            intEnvironment[:solarAzimuth] = hEnvironment['solarAzimuth']
+                        end
+
+                        if hEnvironment.has_key?('solarElevation')
+                            intEnvironment[:solarElevation] = hEnvironment['solarElevation']
+                        end
+
+                        intEnvironment
+
+                    end
+                end
+
+            end
+        end
+    end
+end

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

@@ -0,0 +1,88 @@
+require_relative 'module_identifier'
+require_relative 'module_dateTime'
+require_relative 'module_objective'
+require_relative 'module_pass'
+require_relative 'module_instrument'
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module MdJson
+  
+                module Event
+                    def self.unpack(hEvent, responseObj, inContext = nil)
+                        @MessagePath = ADIWG::Mdtranslator::Readers::MdJson::MdJson
+
+                        intMetadataClass = InternalMetadata.new
+                        intEvent = intMetadataClass.newEvent
+
+                        outContext = 'Event'
+                        outContext = inContext + ' > ' + outContext unless inContext.nil?
+
+                        if hEvent.has_key?('eventId')
+                            intEvent[:eventId] = hEvent['eventId']
+                        else
+                            @MessagePath.issueWarning(40, responseObj, outContext)
+                        end
+
+                        if hEvent.has_key?('identifier')
+                            intEvent[:identifier] = Identifier.unpack(hEvent['identifier'], responseObj, outContext)
+                        else
+                            @MessagePath.issueWarning(40, responseObj, outContext)
+                        end
+
+                        if hEvent.has_key?('trigger')
+                            intEvent[:trigger] = hEvent['trigger']
+                        else
+                            @MessagePath.issueWarning(40, responseObj, outContext)
+                        end
+
+                        if hEvent.has_key?('context')
+                            intEvent[:context] = hEvent['context']
+                        else
+                            @MessagePath.issueWarning(40, responseObj, outContext)
+                        end
+
+                        if hEvent.has_key?('sequence')
+                            intEvent[:sequence] = hEvent['sequence']
+                        else
+                            @MessagePath.issueWarning(40, responseObj, outContext,)
+                        end
+
+                        if hEvent.has_key?('time')
+                            intEvent[:time] = DateTime.unpack(hEvent['time'], responseObj, outContext)
+                        else
+                            @MessagePath.issueWarning(40, responseObj, outContext)
+                        end
+
+                        if hEvent.has_key?('expectedObjective')
+                            hEvent['expectedObjective'].each do |item|
+                                hReturn = Objective.unpack(item, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intEvent[:expectedObjectives] << hReturn
+                                end
+                            end
+                        end
+
+                        if hEvent.has_key?('relatedPass')
+                            intEvent[:relatedPass] = Pass.unpack(hEvent['relatedPass'], responseObj, outContext)
+                        end
+
+                        if hEvent.has_key?('relatedSensor')
+                            hEvent['relatedSensor'].each do |item|
+                                hReturn = Instrument.unpack(item, responseObj, outContext)
+                                unless hReturn.nil?
+                                    intEvent[:relatedSensors] << hReturn
+                                end
+                            end
+                        end
+
+                        intEvent
+
+                    end
+                end
+
+            end
+        end
+    end
+end

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