adiwg-mdtranslator 2.16.1 → 2.17.1

data/lib/adiwg/mdtranslator/writers/iso19115_1/classes/class_source.rb

@@ -1,21 +1,18 @@
-# ISO <<Class>> LI_Source
+# ISO <<Abstract>> Source
 # 19115-1 writer output in XML
 
 # History:
-# 	Stan Smith 2019-04-10 original script.
+# 	Stan Smith 2019-09-27 original script.
 
-require_relative 'class_resolution'
-require_relative 'class_referenceSystem'
-require_relative 'class_citation'
-require_relative 'class_scope'
-require_relative 'class_processStep'
+require_relative 'class_liSource'
+require_relative 'class_leSource'
 
 module ADIWG
    module Mdtranslator
       module Writers
          module Iso19115_1
 
-            class LI_Source
+            class Source
 
                def initialize(xml, hResponseObj)
                   @xml = xml
@@ -25,99 +22,26 @@ module ADIWG
                def writeXML(hSource, inContext = nil)
 
                   # classes used
-                  resolutionClass = MD_Resolution.new(@xml, @hResponseObj)
-                  referenceClass = MD_ReferenceSystem.new(@xml, @hResponseObj)
-                  citationClass = CI_Citation.new(@xml, @hResponseObj)
-                  scopeClass = MD_Scope.new(@xml, @hResponseObj)
-                  stepClass = LI_ProcessStep.new(@xml, @hResponseObj)
+                  liSourceClass = LI_Source.new(@xml, @hResponseObj)
+                  leSourceClass = LE_Source.new(@xml, @hResponseObj)
 
-                  outContext = 'source'
-                  outContext = inContext + ' source' unless inContext.nil?
+                  outContext = inContext
 
-                  # source - id (tag attribute id="")
-                  attributes = {}
-                  s = hSource[:sourceId]
-                  unless s.nil?
-                     attributes = { id: s.gsub(/[^0-9A-Za-z]/,'') }
-                  end
-
-                  @xml.tag!('mrl:LI_Source', attributes) do
-
-                     # source - description
-                     unless hSource[:description].nil?
-                        @xml.tag!('mrl:description') do
-                           @xml.tag!('gco:CharacterString', hSource[:description])
-                        end
-                     end
-                     if hSource[:description].nil? && @hResponseObj[:writerShowTags]
-                        @xml.tag!('mrl:description')
-                     end
-
-                     # source - spatial resolution {MD_Resolution}
-                     unless hSource[:spatialResolution].empty?
-                        @xml.tag!('mrl:sourceSpatialResolution') do
-                           resolutionClass.writeXML(hSource[:spatialResolution], outContext)
-                        end
-                     end
-                     if hSource[:spatialResolution].empty? && @hResponseObj[:writerShowTags]
-                        @xml.tag!('mrl:sourceSpatialResolution')
-                     end
+                  # use LE_Source if hSource has any ...
+                  # processedLevel, resolution
 
-                     # source - reference system {MD_ReferenceSystem}
-                     unless hSource[:referenceSystem].empty?
-                        @xml.tag!('mrl:sourceReferenceSystem') do
-                           referenceClass.writeXML(hSource[:referenceSystem])
-                        end
-                     end
-                     if hSource[:referenceSystem].empty? && @hResponseObj[:writerShowTags]
-                        @xml.tag!('mrl:sourceReferenceSystem')
-                     end
+                  useLE = false
+                  useLE = true unless hSource[:processedLevel].empty?
+                  useLE = true unless hSource[:resolution].empty?
 
-                     # source - citation {CI_Citation}
-                     unless hSource[:sourceCitation].empty?
-                        @xml.tag!('mrl:sourceCitation') do
-                           citationClass.writeXML(hSource[:sourceCitation], outContext)
-                        end
-                     end
-                     if hSource[:sourceCitation].empty? && @hResponseObj[:writerShowTags]
-                        @xml.tag!('mrl:sourceCitation')
-                     end
-
-                     # source - metadata [] {CI_Citation}
-                     aCitations = hSource[:metadataCitations]
-                     aCitations.each do |hCitation|
-                        @xml.tag!('mrl:sourceMetadata') do
-                           citationClass.writeXML(hCitation, outContext)
-                        end
-                     end
-                     if aCitations.empty? && @hResponseObj[:writerShowTags]
-                        @xml.tag!('mrl:sourceMetadata')
-                     end
-
-                     # source - scope {MD_Scope}
-                     unless hSource[:scope].empty?
-                        @xml.tag!('mrl:scope') do
-                           scopeClass.writeXML(hSource[:scope], outContext)
-                        end
-                     end
-                     if hSource[:scope].empty? && @hResponseObj[:writerShowTags]
-                        @xml.tag!('mrl:scope')
-                     end
-
-                     # source - process step [] {LI_ProcessStep}
-                     aSteps = hSource[:sourceSteps]
-                     aSteps.each do |hStep|
-                        @xml.tag!('mrl:sourceStep') do
-                           stepClass.writeXML(hStep)
-                        end
-                     end
-                     if aSteps.empty? && @hResponseObj[:writerShowTags]
-                        @xml.tag!('mrl:sourceStep')
-                     end
+                  if useLE
+                     leSourceClass.writeXML(hSource, outContext)
+                  else
+                     liSourceClass.writeXML(hSource, outContext)
+                  end
 
-                  end # mrl:LI_Source tag
                end # writeXML
-            end # LI_Source class
+            end # Source class
 
          end
       end

data/lib/adiwg/mdtranslator/writers/iso19115_1/iso19115_1_writer_messages_eng.yml

@@ -130,3 +130,14 @@ messageList:
    - {id: 400, message: "invalid topic category"}
 
    - {id: 410, message: "temporal extent must have a TimeInstant or TimePeriod"}
+
+   - {id: 420, message: "algorithm citation is missing"}
+   - {id: 421, message: "algorithm description is missing"}
+
+   - {id: 430, message: "processing identifier is missing"}
+
+   - {id: 440, message: "process step report name is missing"}
+
+   - {id: 450, message: "nominal resolution is missing"}
+
+

data/lib/adiwg/mdtranslator/writers/iso19115_2/classes/class_algorithm.rb

@@ -0,0 +1,61 @@
+# ISO <<Class>> LE_Algorithm
+# 19115-2 writer output in XML
+
+# History:
+# 	Stan Smith 201-09-25 original script.
+
+require_relative '../iso19115_2_writer'
+require_relative 'class_citation'
+
+module ADIWG
+   module Mdtranslator
+      module Writers
+         module Iso19115_2
+
+            class LE_Algorithm
+
+               def initialize(xml, hResponseObj)
+                  @xml = xml
+                  @hResponseObj = hResponseObj
+                  @NameSpace = ADIWG::Mdtranslator::Writers::Iso19115_2
+               end
+
+               def writeXML(hAlgorithm, inContext = nil)
+
+                  # classes used
+                  citationClass = CI_Citation.new(@xml, @hResponseObj)
+
+                  outContext = 'algorithm'
+                  outContext = inContext + ' ' + outContext unless inContext.nil?
+
+                  @xml.tag!('gmi:LE_Algorithm') do
+
+                     # algorithm - citation {CI_Citation} (required)
+                     hCitation = hAlgorithm[:citation]
+                     unless hCitation.empty?
+                        @xml.tag!('gmi:citation') do
+                           citationClass.writeXML(hCitation, outContext)
+                        end
+                     end
+                     if hCitation.empty?
+                        @NameSpace.issueWarning(390, 'gmi:citation', outContext)
+                     end
+
+                     # algorithm - description (required)
+                     unless hAlgorithm[:description].nil?
+                        @xml.tag!('gmi:description') do
+                           @xml.tag!('gco:CharacterString', hAlgorithm[:description])
+                        end
+                     end
+                     if hAlgorithm[:description].nil?
+                        @NameSpace.issueWarning(391, 'gmi:description', outContext)
+                     end
+
+                  end # gmi:LE_Algorithm tag
+               end # writeXML
+            end # LE_Algorithm class
+
+         end
+      end
+   end
+end

data/lib/adiwg/mdtranslator/writers/iso19115_2/classes/class_leProcessStep.rb

@@ -0,0 +1,153 @@
+# ISO <<Class>> LE_ProcessStep
+# 19115-2 writer output in XML
+
+# History:
+# 	Stan Smith 2019-09-25 original script.
+
+require_relative '../iso19115_2_writer'
+require_relative 'class_responsibleParty'
+require_relative 'class_source'
+require_relative 'class_processing'
+require_relative 'class_processReport'
+
+module ADIWG
+   module Mdtranslator
+      module Writers
+         module Iso19115_2
+
+            class LE_ProcessStep
+
+               def initialize(xml, hResponseObj)
+                  @xml = xml
+                  @hResponseObj = hResponseObj
+                  @NameSpace = ADIWG::Mdtranslator::Writers::Iso19115_2
+               end
+
+               def writeXML(hStep, inContext = nil)
+
+                  # classes used
+                  partyClass = CI_ResponsibleParty.new(@xml, @hResponseObj)
+                  sourceClass = Source.new(@xml, @hResponseObj)
+                  processingClass = LE_Processing.new(@xml, @hResponseObj)
+                  reportClass = LE_ProcessStepReport.new(@xml, @hResponseObj)
+
+                  outContext = 'process step'
+                  outContext = outContext + ' ' + hStep[:stepId].to_s unless hStep[:stepId].nil?
+                  outContext = inContext + ' ' + outContext unless inContext.nil?
+
+                  # process step - id
+                  attributes = {}
+                  s = hStep[:stepId]
+                  unless s.nil?
+                     attributes = { id: s.gsub(/[^0-9A-Za-z]/,'') }
+                  end
+
+                  @xml.tag!('gmi:LE_ProcessStep', attributes) do
+
+                     # process step - description (required)
+                     unless hStep[:description].nil?
+                        @xml.tag!('gmd:description') do
+                           @xml.tag!('gco:CharacterString', hStep[:description])
+                        end
+                     end
+                     if hStep[:description].nil?
+                        @NameSpace.issueWarning(260, 'gmd:description', outContext)
+                     end
+
+                     # process step - rationale
+                     unless hStep[:rationale].nil?
+                        @xml.tag!('gmd:rationale') do
+                           @xml.tag!('gco:CharacterString', hStep[:rationale])
+                        end
+                     end
+                     if hStep[:rationale].nil? && @hResponseObj[:writerShowTags]
+                        @xml.tag!('gmd:rationale')
+                     end
+
+                     # process step - datetime
+                     hPeriod = hStep[:timePeriod]
+                     unless hPeriod.empty?
+                        hDate = hPeriod[:startDateTime]
+                        if hDate.empty?
+                           hDate = hPeriod[:endDateTime]
+                        end
+                        date = hDate[:dateTime]
+                        dateResolution = hDate[:dateResolution]
+                        s = AdiwgDateTimeFun.stringDateTimeFromDateTime(date, dateResolution)
+                        if s != 'ERROR'
+                           @xml.tag!('gmd:dateTime') do
+                              @xml.tag!('gco:DateTime', s)
+                           end
+                        end
+                     end
+                     if hPeriod.empty? && @hResponseObj[:writerShowTags]
+                        @xml.tag!('gmd:dateTime')
+                     end
+
+                     # process step - processor [] {CI_ResponsibleParty}
+                     aParties = hStep[:processors]
+                     aParties.each do |hRParty|
+                        role = hRParty[:roleName]
+                        aParties = hRParty[:parties]
+                        aParties.each do |hParty|
+                           @xml.tag!('gmd:processor') do
+                              partyClass.writeXML(role, hParty, outContext)
+                           end
+                        end
+                     end
+                     if aParties.empty? && @hResponseObj[:writerShowTags]
+                        @xml.tag!('gmd:processor')
+                     end
+
+                     # process step - source [] {Source}
+                     aSources = hStep[:stepSources]
+                     aSources.each do |hSource|
+                        @xml.tag!('gmd:source') do
+                           sourceClass.writeXML(hSource)
+                        end
+                     end
+                     if aSources.empty? && @hResponseObj[:writerShowTags]
+                        @xml.tag!('gmd:source')
+                     end
+
+                     # process step - processing information {LE_Processing}
+                     hProcessing = hStep[:processingInformation]
+                     unless hProcessing.empty?
+                        @xml.tag!('gmi:processingInformation') do
+                           processingClass.writeXML(hProcessing, outContext)
+                        end
+                     end
+                     if hProcessing.empty? && @hResponseObj[:writerShowTags]
+                        @xml.tag!('gmi:processingInformation')
+                     end
+
+                     # process step - output [] {Source}
+                     aOutput = hStep[:stepProducts]
+                     aOutput.each do |hSource|
+                        @xml.tag!('gmi:output') do
+                           sourceClass.writeXML(hSource)
+                        end
+                     end
+                     if aOutput.empty? && @hResponseObj[:writerShowTags]
+                        @xml.tag!('gmi:output')
+                     end
+
+                     # process step - report [] {LE_ProcessStepReport}
+                     aReports = hStep[:reports]
+                     aReports.each do |hReport|
+                        @xml.tag!('gmi:report') do
+                           reportClass.writeXML(hReport)
+                        end
+                     end
+                     if aReports.empty? && @hResponseObj[:writerShowTags]
+                        @xml.tag!('gmi:report')
+                     end
+
+                  end # gmd:LE_ProcessStep tag
+               end # writeXML
+            end # LE_ProcessStep class
+
+         end
+      end
+   end
+end

data/lib/adiwg/mdtranslator/writers/iso19115_2/classes/class_leSource.rb

@@ -0,0 +1,134 @@
+# ISO <<Class>> LE_Source
+# 19115-2 writer output in XML
+
+# History:
+# 	Stan Smith 2019-09-25 original script.
+
+require_relative 'class_fraction'
+require_relative 'class_referenceSystem'
+require_relative 'class_citation'
+require_relative 'class_processStep'
+require_relative 'class_rsIdentifier'
+require_relative 'class_nominalResolution'
+
+module ADIWG
+   module Mdtranslator
+      module Writers
+         module Iso19115_2
+
+            class LE_Source
+
+               def initialize(xml, hResponseObj)
+                  @xml = xml
+                  @hResponseObj = hResponseObj
+               end
+
+               def writeXML(hSource, inContext = nil)
+
+                  # classes used
+                  fractionClass = MD_RepresentativeFraction.new(@xml, @hResponseObj)
+                  systemClass = MD_ReferenceSystem.new(@xml, @hResponseObj)
+                  citationClass = CI_Citation.new(@xml, @hResponseObj)
+                  stepClass = ProcessStep.new(@xml, @hResponseObj)
+                  identifierClass = RS_Identifier.new(@xml, @hResponseObj)
+                  resolutionClass = LE_NominalResolution.new(@xml, @hResponseObj)
+
+                  # source - id
+                  attributes = {}
+                  s = hSource[:sourceId]
+                  unless s.nil?
+                     attributes = { id: s.gsub(/[^0-9A-Za-z]/,'') }
+                  end
+
+                  outContext = 'source'
+                  outContext = outContext + ' ' + hSource[:sourceId].to_s unless hSource[:sourceId].nil?
+                  outContext = inContext + ' ' + outContext unless inContext.nil?
+
+                  @xml.tag!('gmi:LE_Source', attributes) do
+
+                     # source - description
+                     unless hSource[:description].nil?
+                        @xml.tag!('gmd:description') do
+                           @xml.tag!('gco:CharacterString', hSource[:description])
+                        end
+                     end
+                     if hSource[:description].nil? && @hResponseObj[:writerShowTags]
+                        @xml.tag!('gmd:description')
+                     end
+
+                     # source - scale denominator {MD_RepresentativeFraction}
+                     hResolution = hSource[:spatialResolution]
+                     unless hResolution[:scaleFactor].nil?
+                        @xml.tag!('gmd:scaleDenominator') do
+                           fractionClass.writeXML(hResolution[:scaleFactor])
+                        end
+                     end
+                     if hResolution[:scaleFactor].nil? && @hResponseObj[:writerShowTags]
+                        @xml.tag!('gmd:scaleDenominator')
+                     end
+
+                     # source - reference system {MD_ReferenceSystem}
+                     hSystem = hSource[:referenceSystem]
+                     unless hSystem.empty?
+                        @xml.tag!('gmd:sourceReferenceSystem') do
+                           systemClass.writeXML(hSystem)
+                        end
+                     end
+                     if hSystem.empty? && @hResponseObj[:writerShowTags]
+                        @xml.tag!('gmd:sourceReferenceSystem')
+                     end
+
+                     # source - citation {CI_Citation}
+                     hCitation = hSource[:sourceCitation]
+                     unless hCitation.empty?
+                        @xml.tag!('gmd:sourceCitation') do
+                           citationClass.writeXML(hCitation, outContext)
+                        end
+                     end
+                     if hCitation.empty? && @hResponseObj[:writerShowTags]
+                        @xml.tag!('gmd:sourceCitation')
+                     end
+
+                     # source - extent [] {EX_Extent} (not implemented)
+
+                     # source - source step [] {ProcessStep}
+                     aSteps = hSource[:sourceSteps]
+                     aSteps.each do |hStep|
+                        @xml.tag!('gmd:sourceStep') do
+                           stepClass.writeXML(hStep)
+                        end
+                     end
+                     if aSteps.empty? && @hResponseObj[:writerShowTags]
+                        @xml.tag!('gmd:sourceStep')
+                     end
+
+                     # source - processed level {RS_Identifier}
+                     hProcess = hSource[:processedLevel]
+                     unless hProcess.empty?
+                        @xml.tag!('gmi:processedLevel') do
+                           identifierClass.writeXML(hProcess, outContext)
+                        end
+                     end
+                     if hProcess.empty? && @hResponseObj[:writerShowTags]
+                        @xml.tag!('gmi:processedLevel')
+                     end
+
+                     # source - resolution {LE_NominalResolution}
+                     hNominal = hSource[:resolution]
+                     unless hNominal.empty?
+                        @xml.tag!('gmi:resolution') do
+                           resolutionClass.writeXML(hNominal, outContext)
+                        end
+                     end
+                     if hNominal.empty? && @hResponseObj[:writerShowTags]
+                        @xml.tag!('gmi:resolution')
+                     end
+
+                  end # gmd:LE_Source tag
+               end # writeXML
+            end # LE_Source class
+
+         end
+      end
+   end
+end