terrapop_models 0.1.0

data/app/models/raster_variable_classification.rb

@@ -0,0 +1,4 @@
+class RasterVariableClassification < ActiveRecord::Base
+  belongs_to :raster_variable
+  belongs_to :mosaic_raster_variable, class_name: 'RasterVariable', foreign_key: 'id'
+end

data/app/models/raster_variable_group_membership.rb

@@ -0,0 +1,4 @@
+class RasterVariableGroupMembership < ActiveRecord::Base
+  belongs_to :raster_group, :inverse_of => :raster_variable_group_memberships
+  belongs_to :raster_variable, :inverse_of => :raster_variable_group_memberships
+end

data/app/models/request_area_data_variable.rb

@@ -0,0 +1,57 @@
+class RequestAreaDataVariable < ActiveRecord::Base
+  belongs_to :extract_request
+  belongs_to :area_data_variable
+
+  # This should be a belongs_to
+  attr_accessor :sample_geog_level
+
+
+  def mnemonic
+    mnem = sample_geog_level ? area_data_variable.construct_synthetic_mnemonic(sample_geog_level)   : area_data_variable.mnemonic
+    
+    adrvml = AreaDataRasterVariableMnemonicLookup.where(composite_mnemonic: mnem).first
+    
+    if adrvml.nil?
+      
+      geography_name = SampleGeogLevel.geography_name(sample_geog_level)
+      
+      desc = area_data_variable.label + " (" + area_data_variable.measurement_type.label + ")"
+      
+      AreaDataRasterVariableMnemonicLookup.create!(composite_mnemonic: mnem, mnemonic: area_data_variable.mnemonic, geog_level: geography_name, dataset_label: (sample_geog_level.nil? ? "" : sample_geog_level.terrapop_sample.short_name_long_year[:short_name]), description: desc)
+    end
+    
+    
+    mnem
+  end
+
+
+  def categories
+    area_data_variable.categories
+  end
+
+
+  def len
+    area_data_variable.len
+  end
+
+
+  def implied_decimal_places
+    area_data_variable.implied_decimal_places
+  end
+
+
+  def label
+    area_data_variable.label
+  end
+
+
+  def data_type
+    area_data_variable.data_type
+  end
+
+
+  def measurement_type
+    area_data_variable.measurement_type
+  end
+
+end

data/app/models/request_geog_unit.rb

@@ -0,0 +1,6 @@
+class RequestGeogUnit < ActiveRecord::Base
+
+  belongs_to :geog_unit
+  belongs_to :extract_request
+
+end

data/app/models/request_raster_dataset.rb

@@ -0,0 +1,4 @@
+class RequestRasterDataset < ActiveRecord::Base
+  belongs_to :raster_dataset
+  belongs_to :extract_request
+end

data/app/models/request_raster_variable.rb

@@ -0,0 +1,147 @@
+class RequestRasterVariable < ActiveRecord::Base
+
+  belongs_to :extract_request
+  belongs_to :raster_variable
+  belongs_to :raster_dataset
+  belongs_to :raster_operation
+  belongs_to :sample_geog_level
+
+
+  def mnemonic
+    RequestRasterVariable.mnemonic(raster_variable, raster_operation, raster_dataset, sample_geog_level)
+  end
+
+  def self.mnemonic(raster_variable, raster_operation, raster_dataset, sample_geog_level)
+    #band = (!raster_dataset.nil? && !raster_dataset.raster_band_index.nil?) ? raster_dataset.raster_band_index : 1
+    #band = 1 if band <= 0
+    
+    geography_name = SampleGeogLevel.geography_name(sample_geog_level)
+    
+    operation = raster_operation.nil? ? "" : "#{raster_operation.opcode}"
+    
+    mnem = "#{raster_variable.mnemonic}_#{operation}_#{geography_name}_#{raster_dataset.mnemonic}"
+    
+    # AreaDataRasterVariableMnemonicLookup(composite_mnemonic: string, mnemonic: string, raster_operation_opcode: string, geog_level: string, dataset_label: string, description: text)
+    
+    adrvml = AreaDataRasterVariableMnemonicLookup.where(composite_mnemonic: mnem).first
+    
+    if adrvml.nil?
+      
+      rd_desc = raster_dataset.long_description
+      desc = raster_variable.label + "; " + rd_desc[:years] + "; " + (raster_operation.nil? ? "" : raster_operation.name) + "(" + raster_variable.units + ")"
+      
+      AreaDataRasterVariableMnemonicLookup.create!(composite_mnemonic: mnem, mnemonic: raster_variable.mnemonic, raster_operation_opcode: operation, geog_level: geography_name, dataset_label: raster_dataset.mnemonic, description: desc)
+    end
+    
+    #"#{raster_variable.mnemonic}_#{operation}_#{band}_#{geography_name}"
+    
+    mnem
+  end
+  
+  
+  ### Moved to SampleGeogLevel
+  #def self.geography_name(sample_geog_level)
+  #  if sample_geog_level.nil?
+  #    ""
+  #  else
+  #    if sample_geog_level.geolink_variable.nil?
+  #      sample_geog_level.terrapop_sample.short_country_name.upcase + "_" + sample_geog_level.country_level.geog_unit.code.upcase
+  #    else
+  #      sample_geog_level.geolink_variable.mnemonic
+  #    end
+  #  end
+  #end
+
+  def geography_name
+    RequestRasterVariable.geography_name(sample_geog_level)
+  end
+
+
+  def mnemonic_sym
+    mnemonic.to_sym
+  end
+
+
+  def is_summary?
+    raster_operation.nil?
+  end
+
+
+  # raster_operation might be nil if this is a raster-only extract.
+  def operation
+    raster_operation.nil? ? "" : "#{raster_operation.opcode}"
+  end
+
+
+  # methods needed for syntax file generation.
+  # For Variable, they're in the database.
+  # For Area_Data_Variable, they're hardcoded similar to the structure here.
+  def filename
+    raster_variable.filename
+  end
+
+
+  def long_mnemonic
+    raster_variable.long_mnemonic
+  end
+
+
+  def raster_categories
+    raster_variable.raster_categories
+  end
+
+
+  def data_type
+    "decimal"
+  end
+
+
+  # shouldn't matter for CSV extracts.
+  def len
+    10
+  end
+
+
+  def implied_decimal_places
+    0
+  end
+
+
+  def categories
+    []
+  end
+
+
+  def label
+    mnemonic
+  end
+
+
+  def to_s
+    mnemonic
+  end
+
+  def self.long_description(request_raster_variables)
+    if request_raster_variables.count > 0
+      mnemonics_operations = {}
+      str = []
+      
+      request_raster_variables.each do |rrv|
+        unless mnemonics_operations.has_key? rrv.raster_variable.mnemonic
+          mnemonics_operations[rrv.raster_variable.mnemonic] = []
+        end
+        mnemonics_operations[rrv.raster_variable.mnemonic] << rrv.raster_operation.name
+      end
+      
+      mnemonics_operations.each do |mnemonic,operations|
+        m = mnemonic.dup
+        str << m.widthize(16) + operations.join(", ")
+      end
+      
+      str.join("\n")
+    else
+      "No Raster Operations"
+    end
+  end
+
+end

data/app/models/request_sample.rb

@@ -0,0 +1,34 @@
+class RequestSample < ActiveRecord::Base
+  belongs_to :sample
+  belongs_to :extract_request
+
+  after_initialize  :init_callback
+  
+  def custom_person_frequency
+    self.sample.p_records / self.custom_sampling_ratio
+  end
+
+  def custom_household_frequency
+    self.sample.h_records / self.custom_sampling_ratio
+  end
+
+  def custom_percent_density
+    self.sample.density / self.custom_sampling_ratio
+  end
+
+  #compute random first hh to sample
+  def generate_first_household_sampled
+
+    # max_household is equal to ceiling(custom_sampling_ratio)
+    max_household = custom_sampling_ratio.ceil
+
+    # first_household-sampled should be at least 1 but no greater than the max_household
+    self.first_household_sampled = rand(max_household) + 1;
+  end
+
+  private
+  def init_callback
+    self.custom_sampling_ratio = 1.0
+  end
+  
+end

data/app/models/request_sample_geog_level.rb

@@ -0,0 +1,4 @@
+class RequestSampleGeogLevel < ActiveRecord::Base
+  belongs_to :extract_request
+  belongs_to :sample_geog_level
+end

data/app/models/request_terrapop_sample.rb

@@ -0,0 +1,6 @@
+class RequestTerrapopSample < ActiveRecord::Base
+
+  belongs_to :terrapop_sample
+  belongs_to :extract_request
+
+end

data/app/models/request_variable.rb

@@ -0,0 +1,104 @@
+class RequestVariable<ActiveRecord::Base
+  belongs_to :variable
+  belongs_to :extract_request
+  belongs_to :attached_variable_pointer
+    
+  # Convenience methods:
+  # The mnemonic of a request variable can be constructed from the requested variable but will be different if it's an
+  # attached variable (variable.mnemonic + attached_pointer suffix.)
+  def mnemonic       
+    attached_variable_pointer ? variable.mnemonic + "_" + attached_variable_pointer.suffix : variable.mnemonic                  
+  end
+  
+  def general?
+    general_detailed_selection == 'G'
+  end
+
+  def detailed?
+    general_detailed_selection == 'D'
+  end
+  
+  def record_type
+    variable.record_type
+  end
+  
+  def data_type
+    variable.data_type
+  end
+  
+  def attached?
+    !attached_variable_pointer.nil?
+  end
+  
+  def attached_variable_pointer_mnemonic
+    attached? ? attached_variable_pointer.mnemonic : nil
+  end
+  
+  def household_variable?
+    variable.household_variable?
+  end
+    
+  def person_variable?
+    variable.person_variable?
+  end
+  
+  def width
+    @computed_width || variable.width
+  end
+  
+  def start
+    @computed_start || variable.start
+  end
+  
+  def start=(s)
+    @computed_start = s
+  end
+  
+  def width=(w)
+    @computed_width = w
+  end
+
+  def long_mnemonic
+    mnemonic = variable.long_mnemonic
+    if detailed?
+      mnemonic += "D"
+    end
+    unless attached_variable_pointer.nil?
+      mnemonic += "_" + attached_variable_pointer.suffix
+    end
+    mnemonic
+  end
+  
+  def full_label
+    attached_variable_pointer ? label_for_attached : label_for_non_attached
+  end
+  
+  def categories
+    if general?
+      variable.general_categories
+    else
+      variable.detailed_categories
+    end
+  end
+  
+  private
+
+  def label_for_attached
+    if detailed?
+      return "#{variable.label} [of #{attached_variable_pointer.label}; detailed version]"
+    elsif general?
+      return "#{variable.label} [of #{attached_variable_pointer.label}; general version]"
+    else
+      return "#{variable.label} [of #{attached_variable_pointer.label}]"
+    end
+  end
+
+  def label_for_non_attached
+    if variable.is_general_detailed?
+      return detailed? ? "#{variable.label} [detailed version]" : "#{variable.label} [general version]"
+    else
+      return variable.label
+    end
+  end
+    
+end

data/app/models/resolution.rb

@@ -0,0 +1,5 @@
+class Resolution < ActiveRecord::Base
+
+  has_many :raster_datasets
+
+end

data/app/models/sample.rb

@@ -0,0 +1,81 @@
+class Sample < ActiveRecord::Base
+
+  has_many :sample_variables
+  has_many :variables
+  has_many :terrapop_samples
+  has_many :sample_detail_values
+
+  has_and_belongs_to_many :tags, join_table: :samples_tags
+
+  belongs_to :country
+
+  default_scope { where(is_old: false) }
+  scope :visible, -> { where(hide_status: 0) }
+
+
+  def api_attributes
+    "TODO"
+  end
+
+
+  def label
+    "#{country.full_name} #{year}"
+  end
+
+
+  def file
+    #File.join(TerrapopConfiguration['application']['environments'][Rails.env]['source_data']['microdata'], data_file_name)
+    File.join(TerrapopConfiguration.settings['source_data']['microdata'], data_file_name)
+  end
+
+
+  def short_country_name
+    country.short_name.upcase
+  end
+
+
+  def short_year
+    year.to_s[-2,2]
+  end
+
+
+  def offset_for_person
+    @@person_offset ||= offset_for_rectype('P')
+  end
+
+
+  def offset_for_household
+    @@household_offset ||= offset_for_rectype('H')
+  end
+
+
+  def offset_for_rectype(rectype)
+    Variable.where(record_type: rectype, is_svar: false).maximum("column_start + column_width")
+  end
+
+
+  def microdata_filesize
+    if filesize.nil? or filesize == 0
+      _file = file
+      if File.exist? _file
+        filesize = File.size _file
+        save
+      elsif File.exist?("#{_file}.gz")
+        filename = "#{_file}.gz"
+        f = File.open(filename, 'rb')
+        unless f.nil?
+          f.seek(File.size(filename) - 4)
+          a = f.readbyte
+          b = f.readbyte
+          c = f.readbyte
+          d = f.readbyte
+          filesize = (a << 24) | (b << 16) + (c << 8) + d;
+          save
+        end
+      end
+    end
+    filesize
+  end
+
+
+end