fcc 0.1.0 → 1.0.0

data/lib/fcc/station/lms_data.rb

@@ -0,0 +1,139 @@
+require 'httparty'
+require 'open-uri'
+require 'net/http'
+require 'uri'
+require 'date'
+require_relative './parsers/lms_data'
+
+module FCC
+  module Station
+    class LmsData
+      BASE_URI = 'https://enterpriseefiling.fcc.gov/dataentry/api/download/dbfile'
+      # include HTTParty
+
+      def find_all_related(call_sign: )
+        stations = find_related_stations(call_sign: call_sign)
+        translators = find_translators_for(call_sign: stations.keys)
+        stations.merge(translators)
+      end
+
+      def find_translators_for(call_sign: )
+        call_signs = [call_sign].flatten
+
+        records = common_station_data.entries.select do |entry|
+          call_signs.any? { |call_sign| call_signs_match?(call_sign, entry['callsign']) }
+        end 
+
+        facility_ids = records.map { |r| r['facility_id'] }.uniq.compact
+
+        matched_facilities = facilities.entries.select do |facility|
+          facility_ids.include?(facility['primary_station']) #{}|| facility_ids.include?(facility['facility_id'])
+        end
+
+        {}.tap do |hash|
+          matched_facilities.each do |record|
+            hash[record['callsign']] = record['facility_id']
+          end
+        end
+      end
+
+      def find_related_stations(call_sign: )
+        call_signs = [call_sign].flatten
+
+        records = common_station_data.entries.select do |entry|
+          call_signs.any? { call_signs_match?(call_sign, entry['callsign']) }
+        end
+
+        correlated_app_ids = records.map { |m| m['eeo_application_id'] }
+        matches = common_station_data.entries.select do |entry|
+          correlated_app_ids.include?(entry['eeo_application_id'])
+        end
+
+        {}.tap do |hash|
+          matches.each do |record|
+            hash[record['callsign']] = record['facility_id']
+          end
+        end
+      end
+
+      def facilities
+        @facilities ||= read(:facility)
+      end
+
+      def common_station_data
+        @common_station_data ||= read(:common_station)
+      end
+
+      def find_facilities(facility_ids:, call_signs: [])
+        matched_facilities = facilities.entries.select do |facility|
+          facility_ids.include?(facility['primary_station']) || facility_ids.include?(facility['facility_id']) || call_signs.include?(facility['callsign'])
+        end
+
+        {}.tap do |hash|
+          matched_facilities.each do |record|
+            hash[record['callsign']] = record['facility_id']
+          end
+        end
+      end
+
+      def find_call_signs(call_signs:)
+        common_station_data.entries.select do |entry|
+          call_signs.any? do |call_sign|
+            call_signs_match?(call_sign, entry['callsign'])
+          end
+        end
+      end
+
+      def read(file_name)
+        key = "#{lms_date}-#{file_name}"
+        remote_url = URI("#{BASE_URI}/#{lms_date}/#{file_name}.zip")
+        FCC.log remote_url
+        contents = FCC.cache.fetch key do
+          begin
+            temp_file = http_download_uri(remote_url)
+            break if temp_file.empty?
+
+            contents = ""
+            Zip::File.open_buffer(temp_file) do |zf| 
+              contents = zf.read(zf.entries.first)
+              break
+            end
+
+            value = contents
+          rescue Exception => e
+            FCC.error(e.message)
+            value = nil
+          ensure
+            value
+          end
+        end
+
+        if contents
+          CSV.parse(contents, col_sep: '|', headers: true)
+        end
+      end
+
+      protected
+
+      def call_signs_match?(ours, theirs)
+        theirs.to_s.upcase.to_s == ours.to_s.upcase.to_s || theirs.to_s.upcase =~ Regexp.new("^#{ours.to_s.upcase}[-—–][A-Z0-9]+$")
+      end
+
+      def http_download_uri(uri)
+        FCC.log 'Downloading ' + uri.to_s
+        begin
+          Tempfile.create { HTTParty.get(uri)&.body }
+        rescue Exception => e
+          FCC.error "=> Exception: '#{e}'. Skipping download."
+
+          raise e
+          return false
+        end
+      end
+
+      def lms_date
+        Date.today.strftime('%m-%d-%Y')
+      end
+    end
+  end
+end

data/lib/fcc/station/parsers/extended_info.rb

@@ -0,0 +1,78 @@
+require 'httparty'
+
+module FCC
+  module Station
+    module Parsers
+      class ExtendedInfo < HTTParty::Parser
+        def parse
+          results = []
+          body.each_line do |row|
+            attrs = {}
+            attrs[:raw] = row
+            fields = row.split('|').slice(1...-1).collect(&:strip).map { |v| v == '-' ? "" : v }
+
+            attrs[:call_sign]                = fields[0]
+            attrs[:frequency]                = parse_frequency(fields[1])
+            attrs[:band]                     = fields[2]
+            attrs[:channel]                  = fields[3]
+            attrs[:antenna_type]             = fields[4] # Directional Antenna (DA) or NonDirectional (ND)
+            attrs[:operating_hours]          = fields[5] if fields[5] && attrs[:band]&.upcase == "AM" # (Only used for AM)
+            attrs[:station_class]            = fields[6]
+            attrs[:region_2_station_class]   = fields[7] if fields[7] && attrs[:band]&.upcase == "AM" # (only used for AM)
+            attrs[:status]                   = fields[8]
+            attrs[:city]                     = fields[9]
+            attrs[:state]                    = fields[10]
+            attrs[:country]                  = fields[11]
+            attrs[:file_number]              = fields[12]  #File Number (Application, Construction Permit or License) or
+            attrs[:signal_strength]          = parse_signal_strength(fields[13]) # Effective Radiated Power --
+            attrs[:effective_radiated_power] = parse_signal_strength(fields[14]) # Effective Radiated Power -- vertically polarized (maximum)
+            attrs[:haat_horizontal]          = fields[15] # Antenna Height Above Average Terrain (HAAT) -- horizontal polarization
+            attrs[:haat_vertical]            = fields[16] # Antenna Height Above Average Terrain (HAAT) -- vertical polarization
+            attrs[:fcc_id]                   = fields[17] # Facility ID Number (unique to each station)
+            attrs[:latitude]                 = parse_latitude(fields[18], fields[19], fields[20], fields[21])
+            attrs[:longitude]                = parse_longitude(fields[22], fields[23], fields[24], fields[25])
+            attrs[:licensed_to]              = fields[26] # Licensee or Permittee
+
+            results << attrs
+          end
+
+          results
+        end
+
+        def parse_longitude(direction, degrees, minutes, seconds)
+          decimal_degrees = degrees.to_i + (minutes.to_f / 60) + (seconds.to_f / 3600)
+
+          "#{direction =~ /W/ ? '-' : ''}#{decimal_degrees}"
+        end
+
+        def parse_latitude(direction, degrees, minutes, seconds)
+          decimal_degrees = degrees.to_i + (minutes.to_f / 60) + (seconds.to_f / 3600)
+
+          "#{direction =~ /S/ ? '-' : ''}#{decimal_degrees}"
+        end
+
+        def parse_signal_strength(power_string)
+          return unless power_string.present?
+
+          number, unit = power_string.strip.scan(/^([0-9.]+)\s+(\w+)$?/).flatten
+          multiplier   = case unit&.downcase
+                          when "w"
+                            1
+                          when "kw"
+                            1000
+                          when "mw"
+                            1000000
+                          else
+                            1
+                         end
+      
+          number.to_f * multiplier
+        end
+
+        def parse_frequency(freq)
+          freq.to_f
+        end
+      end
+    end
+  end
+end

data/lib/fcc/station/parsers/lms_data.rb

@@ -0,0 +1,13 @@
+require 'httparty'
+
+module FCC
+  module Station
+    module Parsers
+      class LmsData < HTTParty::Parser
+        def parse
+          body
+        end
+      end
+    end
+  end
+end

data/lib/fcc/station/record_delegate.rb

@@ -0,0 +1,121 @@
+require 'active_support/inflector'
+
+module FCC
+  module Station
+    class RecordDelegate
+      def initialize(result)
+        @result = result
+      end
+
+      def method_missing(m, *args, &block)
+        return find_result(@result, m) unless @result.is_a?(Array)
+        return find_result(@result.first, m) if @result.size == 1
+
+        filtered_results = @result.filter { |result|
+          result[:status] == 'LIC' # Licensed only, no construction permits
+        }
+
+        filtered_results = filtered_results.collect { |res|
+          find_result(res, m)
+        }.uniq
+
+        filtered_results.size == 1 ? filtered_results.first : filtered_results
+      end
+
+      def to_json
+        return {}.tap do |record|
+          [Station::Result::EXTENDED_ATTRIBUTES | Station::Result::BASIC_ATTRIBUTES].flatten.each do |attr|
+            record[attr.to_sym] = send(attr.to_sym)
+          end
+
+          %i[contact owner community].each do |attr|
+            result = send(attr.to_sym)
+            next unless result
+
+            record[attr] ||= if result.is_a?(Struct)
+                               result.to_h.compact
+                             elsif result.is_a?(Array) && result.compact.size > 0
+                               result
+                             elsif result.present?
+                               result.to_s
+                             end
+          end
+        end
+      end
+
+      def has_data?
+        @result.present?
+      end
+
+      def id
+        super || send(:fcc_id)
+      end
+
+      def frequency
+        super&.to_f
+      end
+
+      def rf_channel
+        super || send(:channel)
+      end
+
+      def operating_hours
+        super&.downcase
+      end
+
+      def owner
+        @owner ||= begin
+          contact = Contact.new(
+            name: party_name || licensed_to,
+            address: party_address_1, 
+            address2: party_address_2, 
+            city: (party_city || city), 
+            state: (party_state || state), 
+            zip_code: party_zip_1,
+            country: country,
+            phone: party_phone
+          )
+
+          contact if contact.to_h.compact.any?
+        end
+      end
+
+      def community
+        @community ||= begin
+          community = Community.new(city: community_city || city, state: community_state || state, country: country)
+          community if community.to_h.compact.any?
+        end
+      end
+
+      def contact
+        contact = main_studio_contact
+
+        return unless contact
+        @contact ||= begin
+          contact = Contact.new(name: contact['contactName'], title: contact['contactTitle'], address: contact['contactAddress1'], address2: contact['contactAddress2'], city: contact['contactCity'], state: contact['contactState'], zip_code: contact['contactZip'], phone: contact['contactPhone'], fax: contact['contactFax'], email: contact['contactEmail'], website: contact['contactWebsite'])
+          contact if contact.to_h.compact.any?
+        end
+      end
+
+      def inspect
+        "<RecordDelegate:[#{band}] #{frequency} #{call_sign} — #{community.city} #{community.state} />"
+      end
+
+      private
+
+      def find_key(result, name)
+        result&.keys&.detect { |d| name.to_s == d.to_s } || result&.keys&.detect { |d| name.to_s == d.to_s.underscore }
+      end
+
+      def find_result(result, name)
+        matched_key = find_key(result, name)
+
+        if matched_key
+          result[matched_key]
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fcc/station/record_group.rb

@@ -0,0 +1,49 @@
+require 'active_support/inflector'
+
+module FCC
+  module Station
+    class RecordGroup
+      def initialize(results = [])
+        @results = results.map do |result| 
+          result.is_a?(RecordDelegate) ? result : RecordDelegate.new(result)
+        end
+      end
+
+      def to_json
+        return {}.tap do |record|
+          [Station::Result::EXTENDED_ATTRIBUTES | Station::Result::BASIC_ATTRIBUTES].flatten.each do |attr|
+            record[attr.to_sym] = result_attribute(attr.to_sym)
+          end
+
+          %i[contact owner community].each do |attr|
+            result = result_attribute(attr.to_sym)
+            next unless result
+
+            record[attr] ||= if result.is_a?(Struct)
+                               result.to_h.compact
+                             elsif result.is_a?(Array) && result.compact.size > 0
+                               result
+                             elsif result.present?
+                               result.to_s
+                             end
+          end
+        end
+      end
+
+      def result_attribute(attr)
+        @results.collect { |r| r.send(attr.to_sym) }.compact.first
+      end
+
+      def method_missing(m, *args, &block)
+        result = result_attribute(m.to_sym)
+
+        if result.is_a?(Array) && result.size == 1 
+          result = result.first
+        end
+
+        result
+      end
+
+    end
+  end
+end

data/lib/fcc/station/result.rb

@@ -0,0 +1,180 @@
+require 'zip'
+
+module FCC
+  module Station
+    class Result
+      EXTENDED_ATTRIBUTES = %i[band signal_strength latitude longitude station_class file_number effective_radiated_power haat_horizontal haat_vertical antenna_type operating_hours licensed_to city state country] # these take a long time to query
+      BASIC_ATTRIBUTES    = %i[id call_sign status rf_channel license_expiration_date facility_type frequency band]
+
+      def initialize(service, call_sign, options = {})
+        @call_sign = call_sign.upcase
+        @service = service
+        @options = options
+
+        data
+
+        self
+      end
+
+      def details_available?
+        exists? && data.latitude.present?
+      end
+
+      def licensed?
+        exists? && data.status == 'LICENSED' && data.license_expiration_date && Time.parse(data.license_expiration_date) > Time.now
+      end
+
+      def exists?
+        grouped_records.any?
+      end
+
+      def to_json(*_args)
+        [].tap do |records|
+          grouped_records.each do |rg|
+            records << rg.to_json
+          end
+        end.flatten.compact.uniq
+      end
+
+      def coordinates_url
+        "https://www.google.com/maps/search/#{latitude},#{longitude}" if latitude.present? && longitude.present?
+      end
+
+      def extended_data_url
+        "https://transition.fcc.gov/fcc-bin/#{@service.to_s.downcase}q?list=4&facid=#{id}"
+      end
+
+      def enterprise_data_url
+        "https://enterpriseefiling.fcc.gov/dataentry/public/tv/publicFacilityDetails.html?facilityId=#{id}"
+      end
+
+      def data
+        @data ||= RecordDelegate.new(Info.new(@service).find(@call_sign))
+      end
+      alias public_data data
+
+      def grouped_records
+        grouped = all_records.group_by do |record|
+          [record.id, record.call_sign, record.band, record.frequency].compact.join('/')
+        end
+
+        [].tap do |res|
+          grouped.each do |_key, values|
+            res << RecordGroup.new(values)
+          end
+        end
+      end
+      alias records grouped_records
+
+      def all_records
+        [public_records, transition_records, related_translators].flatten.compact.filter { |f| f.has_data? }
+      end
+
+      def related_translators
+        @related_translators ||= begin
+          records = lms_data.find_translators_for(call_sign: @call_sign)
+          records.keys.map do |call|
+            RecordDelegate.new(ExtendedInfo.new(@service).find(call))
+          end.select { |f| f.status.upcase == "LIC" }
+        rescue
+          []
+        end
+      end
+
+      def related_stations
+        @related_stations ||= begin
+          records = lms_data.find_related_stations(call_sign: @call_sign)
+          records.keys.map do |call|
+            RecordDelegate.new(ExtendedInfo.new(@service).find(call))
+          end.select { |f| f.status.upcase == "LIC" }      
+        end
+      end
+
+      def related
+        @related ||= begin
+          records = lms_data.find_all_related(call_sign: @call_sign)
+          records.keys.map do |call|
+            ExtendedInfo.new(@service).find(call).collect do |info|
+              RecordDelegate.new(info)
+            end
+          end.flatten.select { |f| f.status.upcase == "LIC" }
+        end
+      end
+
+      def print_broadcast_summary
+        FCC.log "[primary]"
+        transition_records.each do |record|
+          FCC.log "[#{record.band}] #{record.frequency} #{record.call_sign} — #{record.community.city} #{record.community.state}"
+        end
+
+        FCC.log "[translators]"
+        related_translators.each do |record|
+          FCC.log "[#{record.band}] #{record.frequency} #{record.call_sign} — #{record.community.city} #{record.community.state}"
+        end
+
+        FCC.log "[related stations]"
+        related_stations.each do |record|
+          FCC.log "[#{record.band}] #{record.frequency} #{record.call_sign} — #{record.community.city} #{record.community.state}"
+        end
+
+        FCC.log "[all related]"
+        related.each do |record|
+          FCC.log "[#{record.band}] #{record.frequency} #{record.call_sign} — #{record.community.city} #{record.community.state}"
+        end
+
+        nil
+      end
+
+      def lms_data
+        @lms_data ||= LmsData.new
+      end
+
+      def call_signs_match?(ours, theirs)
+        theirs.to_s.upcase.to_s == ours.to_s.upcase.to_s || theirs.to_s.upcase =~ Regexp.new("^#{ours.to_s.upcase}[-—–][A-Z0-9]+$")
+      end
+
+      private
+
+      def public_records
+        public_data_info.map { |r| RecordDelegate.new(r) }
+      end
+
+      def transition_records
+        transition_data_info.map { |r| RecordDelegate.new(r) }
+      end
+
+      def related_records
+        results = related.keys.collect do |call_sign|
+          RecordDelegate.new(ExtendedInfo.new(@service).find(call_sign))
+        end
+      end
+
+      def public_data_info
+        @public_data_info ||= [Info.new(@service).find(@call_sign)]
+      end
+
+      def transition_data_info
+        @transition_data_info ||= ExtendedInfo.new(@service).find(@call_sign)
+      end
+
+      def method_missing(m, *_args)
+        service = if @service == :fm
+                    fm_record = grouped_records.find { |gr| FCC::FM_FULL_SERVICE == gr.band.upcase }
+                    fm_low_power = grouped_records.find { |gr| FCC::FM_LOW_POWER == gr.band.upcase }
+                    fm_booster = grouped_records.find { |gr| FCC::FM_BOOSTER == gr.band.upcase }
+                    fm_translator = grouped_records.find { |gr| FCC::FM_TRANSLATOR == gr.band.upcase }
+
+                    [fm_record, fm_low_power, fm_booster, fm_translator].compact.find { |r| r.send(m.to_sym) }
+                  else
+                    grouped_records.find { |r| r.send(m.to_sym) }
+                  end
+
+        result = service.send(m.to_sym) if service
+
+        result = result.first if result.is_a?(Array) && result.size == 1
+
+        result
+      end
+    end
+  end
+end

data/lib/fcc/station.rb

@@ -0,0 +1,45 @@
+require 'active_support/core_ext/module/delegation'
+require_relative 'station/extended_info'
+require_relative 'station/cache'
+require_relative 'station/index'
+require_relative 'station/info'
+require_relative 'station/result'
+require_relative 'station/lms_data'
+require_relative 'station/record_group'
+require_relative 'station/record_delegate'
+
+module FCC
+  module Station
+    Contact = Struct.new(:name, :title, :address, :address2, :city, :state, :country, :zip_code, :phone, :fax, :email, :website, keyword_init: true)
+    Community = Struct.new(:city, :state, :country, keyword_init: true)
+
+    def self.find_each(service, &block)
+      results = index(service).results
+
+      results.each do |result|
+        yield find(service, result['callSign'])
+      end
+    end
+
+    def self.find(service, call_sign, options = {})
+      Result.new(service, call_sign, options)
+    end
+
+    def self.index(service)
+      case service.to_s.downcase.to_sym
+      when :fm
+        @fm_index ||= Index.new(:fm)
+      when :am
+        @am_index ||= Index.new(:am)
+      when :tv
+        @tv_index ||= Index.new(:tv)
+      else
+        raise "unsupported service #{service}. :fm, :am, and :tv are valid"
+      end
+    end
+
+    def self.extended_info_cache
+      @cache ||= Station::Cache.new
+    end
+  end
+end

data/lib/fcc.rb

@@ -1,3 +1,31 @@
-require 'open-uri'
-require 'fm'
-require 'am'
+# frozen_string_literal: true
+require_relative './fcc/station'
+require_relative './fcc/station/cache'
+require_relative './fcc/station/info'
+require_relative './fcc/station/extended_info'
+require_relative './fcc/station/record_delegate'
+
+module FCC
+  FM_FULL_SERVICE = 'FM'
+  FM_LOW_POWER = 'FL'
+  FM_BOOSTER = 'FB'
+  FM_TRANSLATOR = 'FX'
+
+  def self.cache
+    @cache ||= Station::Cache.new
+  end
+
+  def self.cache=(cache_service)
+    @cache = cache_service
+  end
+
+  def self.log(message)
+    @logger ||= Logger.new($stdout)
+    @logger.info(message)
+  end
+
+  def self.error(message)
+    @error_logger ||= Logger.new($stderr)
+    @error_logger.error(message)
+  end
+end

data/lib/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FCC
+  VERSION = '1.0.0'
+end