adiwg-mdtranslator 1.3.0 → 1.4.0.beta1

data/lib/adiwg/mdtranslator/readers/sbJson/modules_v0/module_dateTime.rb

@@ -0,0 +1,31 @@
+require 'adiwg/mdtranslator/internal/module_dateTimeFun'
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module SbJson
+
+                module DateTime
+
+                    def self.unpack(sDateTime, responseObj)
+
+                        # instance classes needed in script
+                        intMetadataClass = InternalMetadata.new
+
+                        # dateTime
+                        intDateTime = intMetadataClass.newDateTime
+
+                        aDateTimeReturn = AdiwgDateTimeFun.dateTimeFromString(sDateTime)
+                        intDateTime[:dateTime] = aDateTimeReturn[0]
+                        intDateTime[:dateResolution] = aDateTimeReturn[1]
+
+                        return intDateTime
+
+                    end
+
+                end
+
+            end
+        end
+    end
+end

data/lib/adiwg/mdtranslator/readers/sbJson/modules_v0/module_distributionInfo.rb

@@ -0,0 +1,64 @@
+require 'uri'
+require ADIWG::Mdtranslator::Readers::SbJson.readerModule('module_responsibleParty')
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module SbJson
+                module DistributionInfo
+                    def self.unpack(hDistributor, responseObj, intObj)
+                        # instance classes needed in script
+                        intMetadataClass = InternalMetadata.new
+                        intDistributor = intMetadataClass.newDistributor
+
+                        # distributor - distribution contact - required
+                        # We're just injecting the first SB contact here
+                        # with a a role of "distributor", if none just use
+                        # the default SB contact
+                        aCust = {}
+                        dist = intObj[:contacts].find { |c| c[:sbType] == 'Distributor' }
+
+                        unless dist.nil?
+                            aCust['contactId'] = dist[:contactId]
+                            aCust['role'] = 'distributor'
+                        else
+                            aCust['contactId'] = 'SB'
+                            aCust['role'] = 'distributor'
+                        end
+                        intDistributor[:distContact] = ResponsibleParty.unpack(aCust, responseObj)
+
+                        # distributor - distribution order process
+                        if hDistributor.key?('materialRequestInstructions')
+                            aDistOrder = hDistributor['materialRequestInstructions']
+                            unless aDistOrder.empty?
+                                intDistOrder = intMetadataClass.newDistOrder
+                                intDistOrder[:orderInstructions] = hDistributor['materialRequestInstructions']
+                                intDistributor[:distOrderProcs] << intDistOrder
+                            end
+                        end
+
+                        # distributor - distribution transfer options
+                        if hDistributor.key?('distributionLinks')
+                            aDistTransOpt = hDistributor['distributionLinks']
+                            unless aDistTransOpt.empty?
+                                options = intMetadataClass.newDigitalTransOption
+                                aDistTransOpt.each do |opt|
+                                    aOpt = intMetadataClass.newOnlineResource
+                                    aOpt[:olResURI] = opt['uri']
+                                    aOpt[:olResProtocol] = URI.parse(opt['uri']).scheme
+                                    aOpt[:olResName] = opt['title']
+                                    aOpt[:olResDesc] = opt['typeLabel']
+                                    aOpt[:olResFunction] = 'information'
+                                    options[:online] << aOpt
+                                end
+                                intDistributor[:distTransOptions] << options
+                            end
+                        end
+
+                        intDistributor
+                    end
+                end
+            end
+        end
+    end
+end

data/lib/adiwg/mdtranslator/readers/sbJson/modules_v0/module_extent.rb

@@ -0,0 +1,61 @@
+require ADIWG::Mdtranslator::Readers::SbJson.readerModule('module_geographicElement')
+#require ADIWG::Mdtranslator::Readers::SbJson.readerModule('module_temporalElement')
+#require ADIWG::Mdtranslator::Readers::SbJson.readerModule('module_verticalElement')
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module SbJson
+
+                module Extent
+
+                    def self.unpack(hExtent, responseObj)
+
+                        # instance classes needed in script
+                        intMetadataClass = InternalMetadata.new
+                        intExtent = intMetadataClass.newExtent
+
+                        # extent - description
+                        if hExtent.has_key?('description')
+                            s = hExtent['description']
+                            if s != ''
+                                intExtent[:extDesc] = s
+                            end
+                        end
+
+                        # extent - geographic elements
+                        if hExtent.has_key?('geographicElement')
+                            aGeoElements = hExtent['geographicElement']
+                            unless aGeoElements.empty?
+                                intExtent[:extGeoElements] = GeographicElement.unpack(aGeoElements, responseObj)
+                            end
+                        end
+
+                        # extent - temporal elements
+                        # if hExtent.has_key?('temporalElement')
+                        #     hTempElement = hExtent['temporalElement']
+                        #     unless hTempElement.empty?
+                        #         intExtent[:extTempElements] = TemporalElement.unpack(hTempElement, responseObj)
+                        #     end
+                        # end
+                        #
+                        # # extent - vertical elements
+                        # if hExtent.has_key?('verticalElement')
+                        #     aVertElements = hExtent['verticalElement']
+                        #     unless aVertElements.empty?
+                        #         aVertElements.each do |hVertElement|
+                        #             intExtent[:extVertElements] << VerticalElement.unpack(hVertElement, responseObj)
+                        #         end
+                        #     end
+                        # end
+
+                        return intExtent
+
+                    end
+
+                end
+
+            end
+        end
+    end
+end

data/lib/adiwg/mdtranslator/readers/sbJson/modules_v0/module_geoCoordSystem.rb

@@ -0,0 +1,50 @@
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module SbJson
+
+                module GeoCoordSystem
+
+                    def self.unpack(hGeoCrs, intElement, responseObj)
+
+                        intMetadataClass = InternalMetadata.new
+                        intSRS = intMetadataClass.newSRS
+
+                        # get coordinate reference system
+                        # null crs will default to CRS84 in writer
+                        if hGeoCrs.has_key?('properties')
+                            hCRSProp = hGeoCrs['properties']
+
+                            if hCRSProp.has_key?('name')
+                                s = hCRSProp['name']
+                                if s != ''
+                                    intSRS[:srsName] = s
+                                end
+                            end
+
+                            if hCRSProp.has_key?('href')
+                                s = hCRSProp['href']
+                                if s != ''
+                                    intSRS[:srsHref] = s
+                                end
+                            end
+
+                            if hCRSProp.has_key?('type')
+                                s = hCRSProp['type']
+                                if s != ''
+                                    intSRS[:srsType] = s
+                                end
+                            end
+
+                            intElement[:elementSrs] = intSRS
+
+                        end
+
+                    end
+
+                end
+
+            end
+        end
+    end
+end

data/lib/adiwg/mdtranslator/readers/sbJson/modules_v0/module_geoProperties.rb

@@ -0,0 +1,91 @@
+#require ADIWG::Mdtranslator::Readers::SbJson.readerModule('module_temporalElement')
+#require ADIWG::Mdtranslator::Readers::SbJson.readerModule('module_verticalElement')
+#require ADIWG::Mdtranslator::Readers::SbJson.readerModule('module_resourceIdentifier')
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module SbJson
+
+                module GeoProperties
+
+                    def self.unpack(hGeoProps, intElement, responseObj)
+
+                        # set element extent - (default true)
+                        intElement[:elementIncludeData] = true
+                        if hGeoProps.has_key?('includesData')
+                            if !hGeoProps['includesData']
+                                intElement[:elementIncludeData] = false
+                            end
+                        end
+
+                        # set element feature name
+                        if hGeoProps.has_key?('featureName')
+                            s = hGeoProps['featureName']
+                            if s != ''
+                                intElement[:elementName] = s
+                            end
+                        end
+
+                        # set element description
+                        if hGeoProps.has_key?('description')
+                            s = hGeoProps['description']
+                            if s != ''
+                                intElement[:elementDescription] = s
+                            end
+                        end
+
+                        # # set temporal information
+                        # if hGeoProps.has_key?('temporalElement')
+                        #     hTempEle = hGeoProps['temporalElement']
+                        #     unless hTempEle.empty?
+                        #         intElement[:temporalElements] = TemporalElement.unpack(hTempEle, responseObj)
+                        #     end
+                        # end
+                        #
+                        # # set vertical information
+                        # if hGeoProps.has_key?('verticalElement')
+                        #     aVertEle = hGeoProps['verticalElement']
+                        #     unless aVertEle.empty?
+                        #         aVertEle.each do |hVertEle|
+                        #             intElement[:verticalElements] << VerticalElement.unpack(hVertEle, responseObj)
+                        #         end
+                        #     end
+                        # end
+                        #
+                        # # set other assigned IDs
+                        # if hGeoProps.has_key?('identifier')
+                        #     aResIds = hGeoProps['identifier']
+                        #     unless aResIds.empty?
+                        #         aResIds.each do |hIdentifier|
+                        #             intElement[:elementIdentifiers] << ResourceIdentifier.unpack(hIdentifier, responseObj)
+                        #         end
+                        #     end
+                        # end
+                        #
+                        # # set feature scope
+                        # if hGeoProps.has_key?('featureScope')
+                        #     s = hGeoProps['featureScope']
+                        #     if s != ''
+                        #         intElement[:elementScope] = s
+                        #     end
+                        # end
+                        #
+                        # # set feature acquisition methodology
+                        # if hGeoProps.has_key?('featureAcquisitionMethod')
+                        #     s = hGeoProps['featureAcquisitionMethod']
+                        #     if s != ''
+                        #         intElement[:elementAcquisition] = s
+                        #     end
+                        # end
+
+                        return intElement
+
+                    end
+
+                end
+
+            end
+        end
+    end
+end

data/lib/adiwg/mdtranslator/readers/sbJson/modules_v0/module_geographicElement.rb

@@ -0,0 +1,161 @@
+require ADIWG::Mdtranslator::Readers::SbJson.readerModule('module_geoCoordSystem')
+require ADIWG::Mdtranslator::Readers::SbJson.readerModule('module_geoProperties')
+require ADIWG::Mdtranslator::Readers::SbJson.readerModule('module_boundingBox')
+#require ADIWG::Mdtranslator::Readers::SbJson.readerModule('module_point')
+#require ADIWG::Mdtranslator::Readers::SbJson.readerModule('module_lineString')
+#require ADIWG::Mdtranslator::Readers::SbJson.readerModule('module_polygon')
+
+module ADIWG
+    module Mdtranslator
+        module Readers
+            module SbJson
+
+                module GeographicElement
+
+                    def self.unpack(aGeoElements, responseObj)
+
+                        # only one geometry is allowed per geographic element.
+                        # ... in GeoJSON each geometry is allowed a bounding box;
+                        # ... This code splits bounding boxes to separate elements
+
+                        # instance classes needed in script
+                        aIntGeoEle = Array.new
+
+                        aGeoElements.each do |hGeoJsonElement|
+
+                            # instance classes needed in script
+                            intMetadataClass = InternalMetadata.new
+                            hGeoElement = intMetadataClass.newGeoElement
+
+                            # find geographic element type
+                            if hGeoJsonElement.has_key?('type')
+                                elementType = hGeoJsonElement['type']
+                            else
+                                # invalid geographic element
+                                return nil
+                            end
+
+                            # set geographic element id
+                            if hGeoJsonElement.has_key?('id')
+                                s = hGeoJsonElement['id']
+                                if s != ''
+                                    hGeoElement[:elementId] = s
+                                end
+                            end
+
+                            # set geographic element coordinate reference system - CRS
+                            if hGeoJsonElement.has_key?('crs')
+                                hGeoCrs = hGeoJsonElement['crs']
+                                GeoCoordSystem.unpack(hGeoCrs, hGeoElement, responseObj)
+                            end
+
+                            # set geographic element properties
+                            if hGeoJsonElement.has_key?('properties')
+                                hGeoProps = hGeoJsonElement['properties']
+                                GeoProperties.unpack(hGeoProps, hGeoElement, responseObj)
+                            end
+
+                            # process geographic element bounding box
+                            # the bounding box must be represented as a separate geographic element for ISO
+                            # need to make a deep copy of current state of geographic element for bounding box
+                            if hGeoJsonElement.has_key?('bbox')
+                                if hGeoJsonElement['bbox'].length == 4
+                                    aBBox = hGeoJsonElement['bbox']
+
+                                    boxElement = Marshal.load(Marshal.dump(hGeoElement))
+                                    boxElement[:elementGeometry] = BoundingBox.unpack(aBBox, responseObj)
+
+                                    aIntGeoEle << boxElement
+                                end
+                            end
+
+                            # unpack geographic element
+                            case elementType
+
+                                # GeoJSON Features
+                                when 'Feature'
+                                    if hGeoJsonElement.has_key?('geometry')
+                                        hGeometry = hGeoJsonElement['geometry']
+
+                                        # geoJSON requires geometry to be 'null' when geometry is bounding box only
+                                        # JSON null converts in parsing to ruby nil
+                                        unless hGeometry.nil?
+                                            unless hGeometry.empty?
+                                                if hGeometry.has_key?('type')
+                                                    geometryType = hGeometry['type']
+                                                    aCoordinates = hGeometry['coordinates']
+                                                    unless aCoordinates.empty?
+                                                        case geometryType
+                                                            when 'Point', 'MultiPoint'
+                                                                hGeoElement[:elementGeometry] = ADIWG::Mdtranslator::Point.unpack(aCoordinates, geometryType, responseObj)
+                                                            when 'LineString', 'MultiLineString'
+                                                                hGeoElement[:elementGeometry] = ADIWG::Mdtranslator::LineString.unpack(aCoordinates, geometryType, responseObj)
+                                                            when 'Polygon', 'MultiPolygon'
+                                                                hGeoElement[:elementGeometry] = Polygon.unpack(aCoordinates, geometryType, responseObj)
+                                                            else
+                                                                # log - the GeoJSON geometry type is not supported
+                                                        end
+                                                        aIntGeoEle << hGeoElement
+                                                    end
+                                                end
+                                            end
+                                        end
+
+                                    end
+
+                                # GeoJSON Feature Collection
+                                when 'FeatureCollection'
+                                    if hGeoJsonElement.has_key?('features')
+                                        aFeatures = hGeoJsonElement['features']
+                                        unless aFeatures.empty?
+                                            intGeometry = intMetadataClass.newGeometry
+                                            intGeometry[:geoType] = 'MultiGeometry'
+                                            intGeometry[:geometry] = GeographicElement.unpack(aFeatures, responseObj)
+                                            hGeoElement[:elementGeometry] = intGeometry
+                                            aIntGeoEle << hGeoElement
+                                        end
+                                    end
+
+                                # GeoJSON Geometries
+                                when 'Point', 'MultiPoint'
+                                    aCoordinates = hGeoJsonElement['coordinates']
+                                    hGeoElement[:elementGeometry] = ADIWG::Mdtranslator::Point.unpack(aCoordinates, elementType, responseObj)
+                                    aIntGeoEle << hGeoElement
+
+                                when 'LineString', 'MultiLineString'
+                                    aCoordinates = hGeoJsonElement['coordinates']
+                                    hGeoElement[:elementGeometry] = ADIWG::Mdtranslator::LineString.unpack(aCoordinates, elementType, responseObj)
+                                    aIntGeoEle << hGeoElement
+
+                                when 'Polygon', 'MultiPolygon'
+                                    aCoordinates = hGeoJsonElement['coordinates']
+                                    hGeoElement[:elementGeometry] = Polygon.unpack(aCoordinates, elementType, responseObj)
+                                    aIntGeoEle << hGeoElement
+
+                                # GeoJSON Geometry Collection
+                                when 'GeometryCollection'
+                                    if hGeoJsonElement.has_key?('geometries')
+                                        aGeometries = hGeoJsonElement['geometries']
+                                        unless aGeometries.empty?
+                                            intGeometry = intMetadataClass.newGeometry
+                                            intGeometry[:geoType] = 'MultiGeometry'
+                                            intGeometry[:geometry] = GeographicElement.unpack(aGeometries, responseObj)
+                                            hGeoElement[:elementGeometry] = intGeometry
+                                            aIntGeoEle << hGeoElement
+                                        end
+                                    end
+
+                            end
+
+                        end
+
+                        return aIntGeoEle
+
+                    end
+
+                end
+
+            end
+        end
+    end
+end