terrapop_models 0.1.0

data/app/models/nhgis/breakdown_var.rb

@@ -0,0 +1,8 @@
+require 'nhgis_database'
+module Nhgis
+  class BreakdownVar < NhgisActiveRecord::Base
+    belongs_to :breakdown_value_set
+    belongs_to :dataset
+    
+  end
+end

data/app/models/nhgis/data_file.rb

@@ -0,0 +1,43 @@
+require 'nhgis_database'
+module Nhgis
+  class DataFile < NhgisActiveRecord::Base
+
+    belongs_to :data_group
+    belongs_to :breakdown_combo
+    belongs_to :data_file_type
+    has_many :data_record_ranges
+
+    def geog_level
+      data_group.geog_level
+    end
+
+    def geog_unit
+      data_group.geog_unit
+    end
+
+    def datatime_label
+      datatime_time_instance.label
+    end
+
+    def geogtime_instance
+      data_group.geotime.time_instance
+    end
+
+    def geogtime_label
+      geogtime_instance.label
+    end
+
+    def geog_time_instance_id
+      data_group.geog_time_instance_id
+    end
+
+    def datatime_time_instance
+      data_group.datatime
+    end
+
+    def gisjoin_geog_vars
+      data_group.geog_vars_for_gis_join
+    end
+    
+  end
+end

data/app/models/nhgis/data_file_type.rb

@@ -0,0 +1,17 @@
+require 'nhgis_database'
+module Nhgis
+  class DataFileType < NhgisActiveRecord::Base
+
+    def var_code
+      label[0]
+    end
+
+    def is_estimate?
+      var_code == 'E'
+    end
+
+    def is_margin_of_error?
+      var_code == 'M'
+    end
+  end
+end

data/app/models/nhgis/data_group.rb

@@ -0,0 +1,125 @@
+require 'nhgis_database'
+module Nhgis
+  class DataGroup < NhgisActiveRecord::Base
+
+    belongs_to :geotime
+    belongs_to :dataset
+    belongs_to :datatime, :class_name => 'TimeInstance'
+    has_many :data_files
+    has_many :source_geog_instances
+
+    def geog_vars
+      geotime.geog_level.geog_vars & dataset.geog_vars
+    end
+
+    def geog_level
+      geotime.geog_level
+    end
+
+    def geog_unit
+      geotime.geog_unit
+    end
+
+    def geog_time_instance_id
+      geotime.time_instance_id
+    end
+
+    def parent_geog_vars(geog_level)
+      parent_level = geog_level.parent
+      parent_level ? parent_geog_vars(parent_level) + geog_level.geog_vars : geog_level.geog_vars
+    end
+
+    def geog_vars_for_gis_join
+      parent_geog_vars(geotime.geog_level) & dataset.geog_vars
+    end
+
+    def available_integ_geog_names
+      self.root.source_geog_instances.map{|sgi| sgi.geog_name.integ_geog_name}.uniq
+    end
+  
+    def data_files_for_breakdown_values(breakdown_values)
+      available_data_files(breakdown_values.map{|bv| bv.istads_id})
+    end
+  
+
+    def available_data_files(breakdown_value_istads_ids)
+      return DataFile.find_all_for(self.id, breakdown_value_istads_ids)
+    end
+
+    def source_geog_instances_for(integ_geog_names)
+      root.source_geog_instances.select{|sgi| integ_geog_names.include? sgi.geog_name.integ_geog_name}.uniq
+    end
+
+    def self.find_all_for(dataset_id, geog_level_id, datatime_instance_id, geogtime_instance_id)
+      #answer the data groups for the specified dataset, and geog levels
+      #  typically, there will be just one data group per dataset/geog level.
+      #  however, expect more than one data group whenever the dataset has multiple time instances
+
+      return [] if dataset_id.nil?        #the dataset id must be provided to get anything back!!
+
+      gt_join_clause = ""
+      gl_where_clause = ""
+      geog_ti_where_clause = ""
+      if !geog_level_id.nil? || !geogtime_instance_id.nil?
+        gt_join_clause = "JOIN geotimes gt ON gt.id = dg.geotime_id"
+        gl_where_clause = "AND gt.geog_level_id = #{geog_level_id}" if !geog_level_id.nil?
+        geog_ti_where_clause = "AND gt.time_instance_id = #{geogtime_instance_id}" if !geogtime_instance_id.nil?
+      end
+
+      data_ti_where_clause = ""
+      data_ti_where_clause = "AND dg.datatime_id = #{datatime_instance_id}" unless datatime_instance_id.nil?
+
+      sql =<<-EOS
+        SELECT DISTINCT dg.* FROM data_groups dg #{gt_join_clause}
+        WHERE dg.dataset_id = #{dataset_id} #{gl_where_clause} #{geog_ti_where_clause} #{data_ti_where_clause}
+        ORDER BY dg.istads_seq
+      EOS
+      find_by_sql(sql)
+    end
+
+    def self.find_all_available_for(dataset_id, geog_level_ids, data_time_instance_ids)
+      #answer the data groups for the specified dataset, and geog levels
+      #  typically, there will be just one data group per dataset/geog level.
+      #  however, expect more than one data group whenever the dataset has multiple time instances
+
+      gl_join_clause = ""
+      gl_where_clause = ""
+      ti_where_clause = ""
+
+      unless geog_level_ids.empty?
+        gl_join_clause = "JOIN geotimes gt ON gt.id = dg.geotime_id"
+        gl_where_clause = "AND gt.geog_level_id in (#{geog_level_ids.join(", ")})"
+      end
+      unless data_time_instance_ids.empty?
+        ti_where_clause = "AND dg.datatime_id in (#{data_time_instance_ids.join(", ")})"
+      end
+      sql =<<-EOS
+        SELECT DISTINCT dg.* FROM data_groups dg #{gl_join_clause}
+        WHERE dg.relative_pathname IS NOT NULL AND 
+        dg.dataset_id = #{dataset_id} #{gl_where_clause} #{ti_where_clause}
+        ORDER BY dg.istads_seq
+      EOS
+      find_by_sql(sql)
+    end
+
+    def extract_output_name(prefix)
+      #
+      #  specify data group's portion of the 'base filename' to which the extract engine should assign selected
+      #  contents of this data file
+      #
+      #  NOTE: derived from: dataset istads_id + time_instance istads_id [ + geotime istads_id] +  geog_level istads_id
+      #
+      dataset_extract_output_name = "_#{self.dataset.istads_id}"
+      datatime_extract_output_name = "_#{self.datatime.istads_id}"
+      geogtime_extract_output_name = "_#{self.geotime.time_instance.istads_id}"
+      geogtime_extract_output_name = "" if geogtime_extract_output_name == datatime_extract_output_name
+      geog_level_extract_output_name = "_#{self.geotime.geog_level.abbr}"
+      "#{prefix}#{dataset_extract_output_name}#{datatime_extract_output_name}#{geogtime_extract_output_name}#{geog_level_extract_output_name}"
+    end
+
+    def root
+      DataGroup.find_by_dataset_id_and_geotime_id(dataset, self.geotime.root)
+    end
+
+  end
+end

data/app/models/nhgis/data_record_range.rb

@@ -0,0 +1,22 @@
+require 'nhgis_database'
+module Nhgis
+  class DataRecordRange < NhgisActiveRecord::Base
+
+    belongs_to :source_geog_instance
+    belongs_to :data_file
+  
+    def to_range
+     Range.new(line_number_min, line_number_max)
+    end
+
+    def to_range_as_indexes
+     Range.new(line_number_min-1, line_number_max-1)
+    end
+
+    def self.available_data_record_ranges(data_file_id, source_geog_instance_ids)
+      return [] if source_geog_instance_ids.count == 0
+      where("source_geog_instance_id IN (#{source_geog_instance_ids.join(", ")}) AND data_file_id = #{data_file_id}").order("line_number_min")
+    end
+
+  end
+end

data/app/models/nhgis/data_table.rb

@@ -0,0 +1,8 @@
+require 'nhgis_database'
+module Nhgis
+  class DataTable < NhgisActiveRecord::Base
+    has_many :agg_data_vars
+    belongs_to :dataset
+    
+  end
+end

data/app/models/nhgis/dataset.rb

@@ -0,0 +1,76 @@
+require 'nhgis_database'
+module Nhgis
+  class Dataset < NhgisActiveRecord::Base
+    has_many :data_tables
+    has_many :data_groups
+    has_many :geog_vars
+    has_many :agg_data_vars, through: :data_tables
+    has_many :breakdown_vars
+    has_many :time_series_table_datasets
+    has_many :time_series_tables , through: :time_series_table_datasets
+    belongs_to :dataset_group
+
+
+    def terrapop_label
+      label_extension = ""                                #assume that a label extension will not be required
+      base_label = dataset_group.label                    #start with the dataset group label as the base label
+
+      if base_label.include? "American Community Survey"          #dataset is an American Community Survey dataset - which can cover multiple years
+        years = terrapop_years.join("-")                          #expecting two years for ACS datasets e.g. [2008, 2012] => "2008-2012"
+        base_label = "#{years} American Community Survey"         #prepend the base label with the years
+        label_extension = ": #{label.split("#{years}, ").last.gsub("]", "")}"
+
+      else                                                #dataset is NOT an ACS dataset; assumption - dataset has but one year
+        #leave the base_label as it is
+        if dataset_group.datasets.size > 1                #provide the label extension when the dataset group has multiple datasets
+          if label.include? " - "
+            label_extension = ": #{label.split(" - ").first}"
+          else
+            label_extension = ": #{label}"
+          end
+        end
+      end
+
+      "United States #{base_label} (NHGIS#{label_extension})"
+    end
+
+
+    def terrapop_short_label
+      short_label = ""
+      base_label = terrapop_label
+      if base_label.include? "NHGIS: "
+        short_label = base_label.split("NHGIS: ").last.chomp(")")
+      end
+      if base_label.include? "American Community Survey"
+        short_label = "ACS #{short_label}"
+      end
+      short_label
+    end
+
+
+    def terrapop_years
+      #answer an array of years (strings) that define the scope of years for the receiver's data groups data (i.e. datatime, not geotime)
+      # e.g. 1790cPop answers [1790]
+      # e.g. 2008_2012_ACSa answers [2008, 2012]
+      # e.g. 1988_1997_CBP answers [1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997]
+      years = data_groups.map{|dg|dg.datatime.label}.uniq
+      years = years.map{|label| label.split("-")}.flatten.uniq.sort
+      raise "years cannot contain a '-'" unless years.select{|string| string.include? "-"}.empty?
+      years
+    end
+
+
+    def self.terrapop_datasets
+      #answer a list of NHGIS datasets referenced by a TimeSeriesTable that have only nation-, state-, or county-level data
+      # Any dataset that is not referenced by a TimeSeriesTable is excluded from the list.
+      Nhgis::Dataset
+          .joins("JOIN time_series_tables_x_datasets ON time_series_tables_x_datasets.dataset_id = datasets.id")
+          .joins("JOIN data_groups ON data_groups.dataset_id = datasets.id AND data_groups.relative_pathname IS NOT NULL")
+          .joins("JOIN geotimes ON geotimes.id = data_groups.geotime_id")
+          .joins("JOIN geog_levels ON geog_levels.id = geotimes.geog_level_id AND geog_levels.istads_id IN ('nation', 'state', 'county')").uniq
+    end
+
+
+  end
+
+end

data/app/models/nhgis/dataset_group.rb

@@ -0,0 +1,6 @@
+require 'nhgis_database'
+module Nhgis
+  class DatasetGroup < NhgisActiveRecord::Base
+    has_many :datasets
+  end
+end

data/app/models/nhgis/geog_level.rb

@@ -0,0 +1,14 @@
+require 'nhgis_database'
+module Nhgis
+  class GeogLevel < NhgisActiveRecord::Base
+
+    has_many :geotimes
+    belongs_to :geog_unit
+  
+    has_many :geog_var_geog_levels
+    has_many :geog_vars,:through=>:geog_var_geog_levels
+
+    scope :nation_state_county, -> {where(["label IN ('county', 'state', 'nation')"])}
+    
+  end
+end

data/app/models/nhgis/geog_level_collection.rb

@@ -0,0 +1,15 @@
+module Nhgis
+  class GeogLevelCollection
+
+    attr_accessor :geogs_with_boundary_files
+    attr_accessor :preselected_geog_levels
+    attr_accessor :geog_level_groups
+
+    def initialize(preselected_geog_levels, available_geog_levels)
+      @preselected_geog_levels = GeogLevel.find_all_by_istads_id(preselected_geog_levels).sort{|a,b| a.istads_seq <=> b.istads_seq}
+      @geog_level_groups = GeogLevelGroup.all_geog_level_groups_using(preselected_geog_levels, available_geog_levels)
+      @geogs_with_boundary_files = GeogLevel.find_geog_levels_having_shapefiles.map{|obj|obj.istads_id}
+    end
+
+  end
+end

data/app/models/nhgis/geog_level_geog_level_group.rb

@@ -0,0 +1,10 @@
+require 'nhgis_database'
+module Nhgis
+  class GeogLevelGeogLevelGroup < NhgisActiveRecord::Base
+    self.table_name = "geog_levels_x_geog_level_groups"
+
+    belongs_to :geog_level
+    belongs_to :geog_level_group
+
+  end
+end

data/app/models/nhgis/geog_level_group.rb

@@ -0,0 +1,87 @@
+require 'nhgis_database'
+module Nhgis
+  class GeogLevelGroup < NhgisActiveRecord::Base
+    has_many :geog_level_geog_level_groups
+    has_many :geog_levels, :through=>:geog_level_geog_level_groups
+
+    def initialize
+      @available_geog_levels = nil
+      @available_geog_unit_hash = nil
+      @available_geog_units = nil
+      @major_count = 0
+      @all_count = 0
+    end
+
+    def self.all_geog_level_groups_using(preselected, available)
+      #groups = find(:all, :order => "istads_seq")
+      groups = order("istads_seq")
+      groups.each{|grp| grp.preselect_disable_using(preselected, available)}
+      groups
+    end
+
+    def grab_geog_levels_for(geog_unit_id, geog_type)
+      hash_for_gu = grab_geog_unit_hash[geog_unit_id]
+      return [] unless hash_for_gu
+
+      hash = hash_for_gu[:geog_level]
+      return [] unless hash
+
+      hash[geog_type] || []
+    end
+
+    def has_major_geog_levels_only
+      initialize_geog_level_group if @all_count == 0
+      @major_count == @all_count
+    end
+
+    def grab_available_geog_units
+      initialize_geog_level_group unless @available_geog_units
+      @available_geog_units
+    end
+
+    def preselect_disable_using(preselected, available)
+      gl_list = grab_available_geog_levels
+      unavailable = GeogLevel.exclude_from(gl_list, available)
+      gl_list.each{|gl|
+        gl.preselect_using(preselected)
+        gl.disable_using(unavailable)
+      }
+    end
+
+    private
+
+    def grab_available_geog_levels
+      initialize_geog_level_group unless @available_geog_levels
+      @available_geog_levels
+    end
+
+    def grab_geog_unit_hash
+      initialize_geog_level_group unless @available_geog_unit_hash
+      @available_geog_unit_hash
+    end
+
+    def initialize_geog_level_group
+      @available_geog_unit_hash = {}
+      @available_geog_units = []
+      @available_geog_levels = GeogLevel.available_geog_levels_for_geog_level_group(self.id)
+      @major_count = 0
+      @all_count = 0
+
+      gl_id_list = @available_geog_levels.map{|gl|gl.id}
+      GeogUnit.geog_units_for_geog_level_ids(gl_id_list).each{|gu|
+        @available_geog_unit_hash[gu.id] = {:geog_level => {"all" => [], "major" => []}}
+        @available_geog_units << gu unless @available_geog_units.include? gu
+      }
+
+      @available_geog_levels.each{|gl|
+        @available_geog_unit_hash[gl.geog_unit_id][:geog_level]["all"] << gl
+        @all_count += 1
+        if gl.is_major?
+          @available_geog_unit_hash[gl.geog_unit_id][:geog_level]["major"] << gl
+          @major_count += 1
+        end
+      }
+    end
+
+  end
+end