aipp 1.0.0 → 2.0.0

data/lib/aipp/regions/LF/aip/obstacles.rb

@@ -0,0 +1,150 @@
+module AIPP::LF::AIP
+  class Obstacles < AIPP::AIP::Parser
+
+    include AIPP::LF::Helpers::Base
+
+    # Map type descriptions to AIXM types and remarks
+    TYPES = {
+      'Antenne' => [:antenna],
+      'Autre' => [:other],
+      'Bâtiment' => [:building],
+      'Câble' => [:other, 'Cable / Câble'],
+      'Centrale thermique' => [:building, 'Thermal power plant / Centrale thermique'],
+      "Château d'eau" => [:tower, "Water tower / Château d'eau"],
+      'Cheminée' => [:chimney],
+      'Derrick' => [:tower, 'Derrick'],
+      'Eglise' => [:tower, 'Church / Eglise'],
+      'Eolienne' => [:wind_turbine],
+      'Eolienne(s)' => [:wind_turbine],
+      'Grue' => [:tower, 'Crane / Grue'],
+      'Mât' => [:mast],
+      'Phare marin' => [:tower, 'Lighthouse / Phare marin'],
+      'Pile de pont' => [:other, 'Bridge piers / Pile de pont'],
+      'Portique' => [:building, 'Arch / Portique'],
+      'Pylône' => [:mast, 'Pylon / Pylône'],
+      'Silo' => [:tower, 'Silo'],
+      'Terril' => [:other, 'Spoil heap / Teril'],
+      'Torchère' => [:chimney, 'Flare / Torchère'],
+      'Tour' => [:tower],
+      'Treillis métallique' => [:other, 'Metallic grid / Treillis métallique']
+    }.freeze
+
+    def parse
+      if AIPP.options.region_options.include? 'lf_obstacles_xlsx'
+        info("reading obstacles from XLSX")
+        @xlsx = read('Obstacles')
+        parse_from_xlsx
+      else
+        parse_from_xml
+      end
+    end
+
+    private
+
+    def parse_from_xlsx
+      # Build obstacles
+      @xlsx.sheet(@xlsx.sheets.find(/^data/i).first).each(
+        name: 'IDENTIFICATEUR',
+        type: 'TYPE',
+        count: 'NOMBRE',
+        longitude: 'LONGITUDE DECIMALE',
+        latitude: 'LATITUDE DECIMALE',
+        elevation: 'ALTITUDE AU SOMMET',
+        height: 'HAUTEUR HORS SOL',
+        height_unit: 'UNITE',
+        horizontal_accuracy: 'PRECISION HORIZONTALE',
+        vertical_accuracy: 'PRECISION VERTICALE',
+        visibility: 'BALISAGE',
+        remarks: 'REMARK',
+        effective_on: 'DATE DE MISE EN VIGUEUR'
+      ).with_index(0) do |row, index|
+        next unless row[:effective_on].to_s.match? /\d{8}/
+        type, type_remarks = TYPES.fetch(row[:type])
+        count = row[:count].to_i
+        obstacle = AIXM.obstacle(
+          source: source(part: 'ENR', position: index),
+          name: row[:name],
+          type: type,
+          xy: AIXM.xy(lat: row[:latitude].to_f, long: row[:longitude].to_f),
+          z: AIXM.z(row[:elevation].to_i, :qnh)
+        ).tap do |obstacle|
+          obstacle.height = AIXM.d(row[:height].to_i, row[:height_unit])
+          if row[:horizontal_accuracy]
+            accuracy = row[:horizontal_accuracy].split
+            obstacle.xy_accuracy = AIXM.d(accuracy.first.to_i, accuracy.last)
+          end
+          if row[:vertical_accuracy]
+            accuracy = row[:horizontal_accuracy].split
+            obstacle.z_accuracy = AIXM.d(accuracy.first.to_i, accuracy.last)
+          end
+          obstacle.marking = row[:visibility].match?(/jour/i)
+          obstacle.lighting = row[:visibility].match?(/nuit/i)
+          obstacle.remarks = {
+            'type' => type_remarks,
+            'number/nombre' => (count if count > 1),
+            'details' => row[:remarks],
+            'effective/mise en vigueur' => (row[:effective_on].to_s.unpack("a4a2a2").join("-") if row[:updated_on])
+          }.to_remarks
+          # Group obstacles
+          if aixm.features.find_by(:obstacle, xy: obstacle.xy).any?
+            warn("duplicate obstacle #{obstacle.name}", severe: false)
+          else
+            if count > 1
+              obstacle_group = AIXM.obstacle_group(
+                source: obstacle.source,
+                name: obstacle.name
+              ).tap do |obstacle_group|
+                obstacle_group.remarks = "#{count} obstacles"
+              end
+              obstacle_group.add_obstacle obstacle
+              add obstacle_group
+            else
+              add obstacle
+            end
+          end
+        end
+      end
+    end
+
+    def parse_from_xml
+      AIPP.cache.obstacle.css(%Q(Obstacle[lk^="[LF]"])).each do |node|
+        # Build obstacles
+        type, type_remarks = TYPES.fetch(node.(:TypeObst))
+        count = node.(:Combien).to_i
+        obstacle = AIXM.obstacle(
+          source: source(part: 'ENR', position: node.line),
+          name: node.(:NumeroNom),
+          type: type,
+          xy: xy_from(node.(:Geometrie)),
+          z: AIXM.z(node.(:AmslFt).to_i, :qnh)
+        ).tap do |obstacle|
+          obstacle.height = AIXM.d(node.(:AglFt).to_i, :ft)
+          obstacle.marking = node.(:Balisage).match?(/jour/i)
+          obstacle.lighting = node.(:Balisage).match?(/nuit/i)
+          obstacle.remarks = {
+            'type' => type_remarks,
+            'number/nombre' => (count if count > 1)
+          }.to_remarks
+        end
+        # Group obstacles
+        if aixm.features.find_by(:obstacle, xy: obstacle.xy).any?
+          warn("duplicate obstacle #{obstacle.name}", severe: false)
+        else
+          if count > 1
+            obstacle_group = AIXM.obstacle_group(
+              source: obstacle.source,
+              name: obstacle.name
+            ).tap do |obstacle_group|
+              obstacle_group.remarks = "#{count} obstacles"
+            end
+            obstacle_group.add_obstacle obstacle
+            add obstacle_group
+          else
+            add obstacle
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/aipp/regions/LF/aip/serviced_airspaces.rb

@@ -0,0 +1,67 @@
+module AIPP::LF::AIP
+  class ServicedAirspaces < AIPP::AIP::Parser
+
+    include AIPP::LF::Helpers::Base
+
+    # Map source types to type and optional local type and skip regexp
+    SOURCE_TYPES = {
+      'FIR' => { type: 'FIR' },
+      'UIR' => { type: 'UIR' },
+      'UTA' => { type: 'UTA' },
+      'CTA' => { type: 'CTA' },
+      'LTA' => { type: 'CTA', local_type: 'LTA' },
+      'TMA' => { type: 'TMA', skip: /geneve/i },   # Geneva listed FYI only
+      'SIV' => { type: 'SECTOR', local_type: 'FIZ/SIV' },   # providing FIS
+      'CTR' => { type: 'CTR' },
+      'RMZ' => { type: 'RAS', local_type: 'RMZ' },
+      'TMZ' => { type: 'RAS', local_type: 'TMZ' },
+      'RMZ-TMZ' => { type: 'RAS', local_type: 'RMZ-TMZ' }
+    }.freeze
+
+    # Map airspace "<type> <name>" to location indicator
+    FIR_LOCATION_INDICATORS = {
+      'BORDEAUX' => 'LFBB',
+      'BREST' => 'LFRR',
+      'MARSEILLE' => 'LFMM',
+      'PARIS' => 'LFFF',
+      'REIMS' => 'LFRR'
+    }.freeze
+
+    def parse
+      SOURCE_TYPES.each do |source_type, target|
+        verbose_info("processing #{source_type}")
+        AIPP.cache.espace.css(%Q(Espace[lk^="[LF][#{source_type} "])).each do |espace_node|
+          # Skip all delegated airspaces
+          next if espace_node.(:Nom).match? /deleg/i
+          next if (re = target[:skip]) && espace_node.(:Nom).match?(re)
+          # Build airspaces and layers
+          AIPP.cache.partie.css(%Q(Partie:has(Espace[pk="#{espace_node['pk']}"]))).each do |partie_node|
+            add(
+              AIXM.airspace(
+                source: source(part: 'ENR', position: espace_node.line),
+                name: [
+                  espace_node.(:Nom),
+                  partie_node.(:NomPartie).remove(/^\.$/).blank_to_nil
+                ].compact.join(' '),
+                type: target[:type],
+                local_type: target[:local_type]
+              ).tap do |airspace|
+                airspace.meta = espace_node.attr('pk')
+                airspace.geometry = geometry_from(partie_node.(:Contour))
+                fail("geometry is not closed") unless airspace.geometry.closed?
+                AIPP.cache.volume.css(%Q(Volume:has(Partie[pk="#{partie_node['pk']}"]))).each do |volume_node|
+                  airspace.add_layer(
+                    layer_from(volume_node).tap do |layer|
+                      layer.location_indicator = FIR_LOCATION_INDICATORS.fetch(airspace.name) if airspace.type == :flight_information_region
+                    end
+                  )
+                end
+              end
+            )
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/aipp/regions/LF/aip/services.rb

@@ -0,0 +1,169 @@
+module AIPP::LF::AIP
+  class Services < AIPP::AIP::Parser
+
+    include AIPP::LF::Helpers::Base
+
+    depends_on :Aerodromes, :ServicedAirspaces
+
+    # Service types and how to treat them
+    SOURCE_TYPES = {
+      'A/A' => :address,
+      'AFIS' => :service,
+      'APP' => :service,
+      'ATIS' => :service,
+      'CCM' => :ignore,      # centre de contrôle militaire
+      'CEV' => :ignore,      # centre d’essai en vol
+      'D-ATIS' => :ignore,   # data link ATIS
+      'FIS' => :service,
+      'PAR' => :service,
+      'SRE' => :ignore,      # surveillance radar element of PAR
+      'TWR' => :service,
+      'UAC' => :ignore,      # upper area control
+      'VDF' => :service,
+      'OTHER' => :service    # no <Service> specified at source
+    }.freeze
+
+    # Map French callsigns to English and service type
+    CALLSIGNS = {
+      'Approche' => { en: 'Approach', service_type: 'APP' },
+      'Contrôle' => { en: 'Control', service_type: 'ACS' },
+      'Information' => { en: 'Information', service_type: 'FIS' },
+      'GCA' => { en: 'GCA', service_type: 'GCA' },
+      'Gonio' => { en: 'Gonio', service_type: 'VDF' },
+      'Prévol' => { en: 'Delivery', service_type: 'SMC' },
+      'Sol' => { en: 'Ground', service_type: 'SMC' },
+      'Tour' => { en: 'Tower', service_type: 'TWR' },
+      'Trafic' => { en: 'Apron', service_type: 'SMC' }
+    }.freeze
+
+    def parse
+      AIPP.cache.service.css(%Q(Service[lk^="[LF]"][pk])).each do |service_node|
+        # Ignore private services/frequencies
+        next if service_node.(:IndicLieu) == 'XX'
+        # Load referenced airport
+        airport = given(service_node.at_css('Ad')&.attr('pk')) do
+          find_by(:airport, meta: _1).first
+        end
+        # Build addresses and services
+        case SOURCE_TYPES.fetch(type_for(service_node))
+        when :address
+          fail "dangling address without airport" unless airport
+          addresses_from(service_node).each { airport.add_address(_1) }
+        when :service
+          given service_from(service_node) do |service|
+            AIPP.cache.frequence.css(%Q(Frequence:has(Service[pk="#{service_node['pk']}"]))).each do |frequence_node|
+              if frequency = frequency_from(frequence_node, service_node)
+                service.add_frequency frequency
+              end
+            end
+            if airport
+              airport.add_unit(service.unit) if airport.units.find(service.unit).none?
+              airport.add_service(service) if airport.services.find(service).none?
+            end
+            given service_node.at_css('Espace')&.attr('pk') do |espace_pk|
+              find_by(:airspace, meta: espace_pk).each do |airspace|
+                airspace.layers.each { _1.add_service(service) }
+              end
+            end
+          end
+        end
+      end
+      # Assign fallback address (default A/A frequency) to all yet radioless airports
+      find_by(:airport).each do |airport|
+        unless airport.services.find_by(:service, type: :aerodrome_control_tower_service).any? || airport.addresses.any?
+          airport.add_address(fallback_address_for(airport.name))
+        end
+      end
+    end
+
+    private
+
+    def type_for(service_node)
+      SOURCE_TYPES.include?(type = service_node.(:Service)) ? type : 'OTHER'
+    end
+
+    def addresses_from(service_node)
+      AIPP.cache.frequence.css(%Q(Frequence:has(Service[pk="#{service_node['pk']}"]))).map do |frequence_node|
+        if frequency = frequency_from(frequence_node, service_node)
+          AIXM.address(
+            type: :radio_frequency,
+            address: frequency.transmission_f
+          ).tap do |address|
+            address.remarks = {
+              'type' => service_node.(:Service),
+              'indicatif/callsign' => frequency.callsigns.map { "#{_2} (#{_1})" }.join("/n")
+            }.to_remarks
+          end
+        end
+      end.compact
+    end
+
+    def fallback_address_for(callsign)
+      AIXM.address(
+        type: :radio_frequency,
+        address: AIXM.f(123.5, :mhz)
+      ).tap do |address|
+        address.remarks = {
+          'type' => 'A/A',
+          'indicatif/callsign' => callsign
+        }.to_remarks
+      end
+    end
+
+    def service_from(service_node)
+      service_type = CALLSIGNS.dig(service_node.(:IndicService), :service_type) || type_for(service_node)
+      service = find_by(:service, type: service_type).first
+      unit = service&.unit
+      unless service
+        service = AIXM.service(type: service_type)
+        unit = find_by(:unit, name: service_node.(:IndicLieu), type: service.guessed_unit_type).first
+        unless unit
+          unit = AIXM.unit(
+            source: source(part: 'GEN', position: service_node.line),
+            organisation: organisation_lf,
+            name: service_node.(:IndicLieu),
+            type: service.guessed_unit_type,
+            class: :icao
+          )
+          add unit
+        end
+        unit.add_service service
+        service
+      end
+    end
+
+    def frequency_from(frequence_node, service_node)
+      frequency = frequence_node.(:Frequence).to_f
+      case
+      when frequency >= 137
+        nil
+      when frequency < 108
+        warn("ignoring too low frequency `#{frequency}'", severe: false)
+        nil
+      else
+        AIXM.frequency(
+          transmission_f: AIXM.f(frequency, :mhz),
+          callsigns: callsigns_from(service_node)
+        ).tap do |frequency|
+          frequency.timetable = timetable_from(frequence_node.(:HorCode))
+          frequency.remarks = frequence_node.(:Remarque)
+        end
+      end
+    end
+
+    def callsigns_from(service_node)
+      if service_node.(:IndicService) == '.'   # auto-information
+        %i(fr en).to_h { [_1, '(auto)'] }
+      else
+        warn("language other than french") unless service_node.(:Langue) == 'fr'
+        english = CALLSIGNS.fetch(service_node.(:IndicService)).fetch(:en)
+        warn("no english translation for callsign `#{service_node.(:IndicService)}'") unless english
+        {
+          fr: "#{service_node.(:IndicLieu)} #{service_node.(:IndicService)}",
+          en: ("#{service_node.(:IndicLieu)} #{english}" if english)
+        }.compact
+      end
+    end
+
+  end
+end

data/lib/aipp/regions/LF/fixtures/aerodromes.yml

@@ -185,9 +185,9 @@ LFDS:
   "28R":
     xy: 44°47'29.9"N 1°14'56.5"E
 LFDU:
-  "07":
+  "06":
     xy: 45°11'42.8"N 0°53'17.3"W
-  "25":
+  "24":
     xy: 45°11'55.8"N 0°52'40.4"W
 LFDX:
   "17":

data/lib/aipp/regions/LF/helpers/base.rb

@@ -12,47 +12,47 @@ module AIPP
 
         def setup
           AIXM.config.voice_channel_separation = :any
-          unless cache.espace
+          unless AIPP.cache.espace
             xml = read('XML_SIA')
-            %i(Ad Bordure Espace Frequence Helistation NavFix Obstacle Partie RadioNav Rwy RwyLgt Service Volume).each do |section|
-              cache[section.downcase] = xml.css("#{section}S")
+            %i(Ad Bordure Espace Frequence Helistation NavFix Obstacle Partie RadioNav Rwy RwyLgt Service Volume).each do |table|
+              AIPP.cache[table.downcase] = xml.css("#{table}S")
             end
             warn("XML_SIA database dump version mismatch") unless xml.at_css('SiaExport').attr(:Version) == VERSION
           end
         end
 
-        def url_for(aip_file)
-          sia_date = options[:airac].date.strftime('%d_%^b_%Y')   # 04_JAN_2018
-          xml_date = options[:airac].date.xmlschema               # 2018-01-04
+        def origin_for(document)
+          sia_date = AIPP.options.airac.date.strftime('%d_%^b_%Y')   # 04_JAN_2018
+          xml_date = AIPP.options.airac.date.xmlschema               # 2018-01-04
           sia_url = "https://www.sia.aviation-civile.gouv.fr/dvd/eAIP_#{sia_date}"
-          case aip_file
+          case document
           when /^Obstacles$/   # obstacles spreadsheet
-            "#{sia_url}/FRANCE/ObstaclesDataZone1MFRANCE_#{xml_date.remove('-')}.xlsx"
-          when /^VAC\-(\w+)/   # aerodrome VAC PDF
-            "#{sia_url}/Atlas-VAC/PDF_AIPparSSection/VAC/AD/AD-2.#{$1}.pdf"
-          when /^VACH\-(\w+)/   # helipad VAC PDF
-            "#{sia_url}/Atlas-VAC/PDF_AIPparSSection/VACH/AD/AD-3.#{$1}.pdf"
-          when /^[A-Z]+-/   # eAIP HTML page (e.g. ENR-5.5)
-            "#{sia_url}/FRANCE/AIRAC-#{xml_date}/html/eAIP/FR-#{aip_file}-fr-FR.html"
+            AIPP::Downloader::HTTP.new(file: "#{sia_url}/FRANCE/ObstaclesDataZone1MFRANCE_#{xml_date.remove('-')}.xlsx")
+#         when /^VAC\-(\w+)/   # aerodrome VAC PDF
+#           AIPP::Downloader::HTTP.new(file: "#{sia_url}/Atlas-VAC/PDF_AIPparSSection/VAC/AD/AD-2.#{$1}.pdf")
+#         when /^VACH\-(\w+)/   # helipad VAC PDF
+#           AIPP::Downloader::HTTP.new(file: "#{sia_url}/Atlas-VAC/PDF_AIPparSSection/VACH/AD/AD-3.#{$1}.pdf")
+#         when /^[A-Z]+-/   # eAIP HTML page (e.g. ENR-5.5)
+#           AIPP::Downloader::HTTP.new(file: "#{sia_url}/FRANCE/AIRAC-#{xml_date}/html/eAIP/FR-#{document}-fr-FR.html")
           else   # SIA XML database dump
-            "XML_SIA_#{xml_date}.xml"
+            AIPP::Downloader::File.new(file: "XML_SIA_#{xml_date}.xml")
           end
         end
 
         # Templates
 
         def organisation_lf
-          unless cache.organisation_lf
-            cache.organisation_lf = AIXM.organisation(
-              source: source(position: 1, aip_file: "GEN-3.1"),
+          unless AIPP.cache.organisation_lf
+            AIPP.cache.organisation_lf = AIXM.organisation(
+              source: source(position: 1, document: "GEN-3.1"),
               name: 'FRANCE',
               type: 'S'
             ).tap do |organisation|
               organisation.id = 'LF'
             end
-            add cache.organisation_lf
+            add AIPP.cache.organisation_lf
           end
-          cache.organisation_lf
+          AIPP.cache.organisation_lf
         end
 
         # Parsersettes
@@ -60,17 +60,17 @@ module AIPP
         # Build a source string
         #
         # @param position [Integer] line on which to find the information
-        # @param section [String] override autodetected section (e.g. "ENR")
-        # @param aip_file [String] override autodetected aip_file
+        # @param part [String] override autodetected part (e.g. "ENR")
+        # @param document [String] override autodetected document (e.g. "ENR-2.1")
         # @return [String] source string
-        def source(position:, section: nil, aip_file: nil)
-          aip_file ||= 'XML_SIA'
-          section ||= aip_file.split(/-(?=\d)/).first
+        def source(position:, part: nil, document: nil)
+          document ||= 'XML_SIA'
+          part ||= document.split(/-(?=\d)/).first
           [
-            options[:region],
-            section,
-            aip_file,
-            options[:airac].date.xmlschema,
+            AIPP.options.region,
+            part,
+            document,
+            AIPP.options.airac.date.xmlschema,
             position
           ].join('|')
         end
@@ -134,7 +134,7 @@ module AIPP
               parts = element.split(',', 3).last.split(/[():,]/)
               # Write explicit geometry from previous iteration
               if (bordure_name, xy = buffer.delete(:fnt))
-                border = borders[bordure_name]
+                border = AIPP.borders.send(bordure_name)
                 geometry.add_segments border.segment(
                   from_position: border.nearest(xy: xy),
                   to_position: border.nearest(xy: xy_from(parts[0]))
@@ -163,10 +163,10 @@ module AIPP
                     radius: d_from(parts[3..4].join(' '))
                   )
                 when 'fnt'
-                  bordure = cache.bordure.at_css(%Q(Bordure[pk="#{parts[3]}"]))
+                  bordure = AIPP.cache.bordure.at_css(%Q(Bordure[pk="#{parts[3]}"]))
                   bordure_name = bordure.(:Code)
                   if bordure_name.match? /:/   # explicit geometry
-                    borders[bordure_name] ||= AIPP::Border.from_array([bordure.(:Geometrie).split])
+                    AIPP.borders[bordure_name] ||= AIPP::Border.from_array([bordure.(:Geometrie).split])
                     buffer[:fnt] = [bordure_name, xy_from(parts[2])]
                     AIXM.point(
                       xy: xy_from(parts[0])

data/lib/aipp/regions/LS/README.md

@@ -0,0 +1,59 @@
+# LS – Switzerland
+
+## Neway API
+
+The NOTAM messages are fetched from the Neway API which is a non-public
+GraphQL API.
+
+You have to set the following environment variables:
+
+* `NEWAY_API_URL` – API endpoint
+* `NEWAY_API_AUTHORIZATION` – the bearer authentication token
+
+The following query object shows all parameters and columns:
+
+```
+{
+  queryNOTAMs(
+    filter: {
+      country: "CHE",       # country as detected by ICAO
+      series: ["W", "B"],   # NOTAM series (first letter of name)
+      region: "LS",         # FIR region (extracted from name)
+      start: 1651449600,    # time window begins (UTC timestamp)
+      end: 1651535999       # time window ends (UTC timestamp)
+    }
+  ) {
+    id                      # internal ID
+    name                    # NOTAM name
+    notamRaw                # raw NOTAM message
+    series                  # NOTAM series (first letter of name)
+    region                  # FIR region (extracted from name)
+    country                 # country as detected by ICAO
+    area                    # NOTAM topic area
+    effectiveFrom           # validity begins (UTC timestamp)
+    validUntil              # validity ends (UTC timestamp)
+  }
+}
+```
+
+## Asynchronous Use
+
+### Command Line Arguments
+
+When used asynchronously, the following command line arguments should be considered:
+
+* `-c` – clear cache (mandatory to create builds more often than once per hour)
+* `-f` – continue on non-fatal errors such as if the validation fails
+* `-q` – suppress all informational output
+* `-x` – crossload fixed versions of malformed NOTAM
+
+### Monitoring
+
+Any output on STDERR should trigger an alert.
+
+## References
+
+* [skybriefing](https://www.skybriefing.com)
+* [AIM Data Catalogue](https://www.aerodatacat.ch)
+* [DABS](https://www.skybriefing.com/de/dabs)
+* [NOTAM Info](https://notaminfo.com/switzerlandmap)