terrapop_models 0.1.0

data/app/models/terrapop_setting.rb

@@ -0,0 +1,11 @@
+class TerrapopSetting < ActiveRecord::Base
+
+  store_accessor :data
+
+  def self.dump_all
+    {self.to_s.underscore.pluralize =>
+      self.all.map { |ts| {'name' => ts.name, 'data' => ts.data} }
+    }
+  end
+
+end

data/app/models/topic.rb

@@ -0,0 +1,7 @@
+class Topic < ActiveRecord::Base
+
+  has_and_belongs_to_many :raster_variables
+  has_and_belongs_to_many :variables
+  has_and_belongs_to_many :area_data_variables
+
+end

data/app/models/ui_text_snippet.rb

@@ -0,0 +1,2 @@
+class UiTextSnippet < ActiveRecord::Base
+end

data/app/models/universe.rb

@@ -0,0 +1,5 @@
+class Universe < ActiveRecord::Base
+
+  has_many :sample_variables
+
+end

data/app/models/user.rb

@@ -0,0 +1,262 @@
+class User < ActiveRecord::Base
+
+  store_accessor :data
+
+  belongs_to :user_role
+  has_many :extract_requests, dependent: :destroy
+
+  attr_accessor :password
+
+  validates :firstname, :lastname, presence: true
+  validates :email, uniqueness: {case_sensitive: false}, format: {with: /\A[^@]+@[^@]+\.[^@]+\z/}
+
+  validates :opt_in, :no_fees, :cite, :send_copy, :data_only, :good_not_evil, presence: true, on: :create
+  validates :password, confirmation: true, length: {minimum: 8}, on: :create
+  validates :password_confirmation, presence: true, on: :create
+
+  validates :opt_in, :no_fees, :cite, :send_copy, :data_only, :good_not_evil, presence: true, on: :update, if: :has_invalid_agreement?
+
+
+  def self.dump_all
+    {
+      'bare_users' => self.all.map { |user|
+        user.attributes.delete_if { |attrb| attrb == 'id' }.map { |attrb, value|
+          if attrb != 'user_role_id'
+            {attrb => value}
+          else
+            {'user_role_id' => UserRole.find(value).role}
+          end
+        }.reduce({}, :merge)
+      }
+    }
+  end
+
+
+  def to_s
+    "id: #{id.nil? ? '<not set>' : id}, email: #{email.nil? ? '<not set>' : email}, microdata_access_allowed: #{microdata_access_is_approved?}"
+  end
+
+
+  def firstname_lastname
+    [firstname, lastname].reject(&:blank?).join(' ')
+  end
+
+
+  def owner_info(without_id = false)
+    if without_id
+      "#{firstname} #{lastname} <#{email}>"
+    else
+      "User[#{id}]: #{firstname} #{lastname} <#{email}>"
+    end
+  end
+
+
+  def is_admin?
+    admin_role = UserRole.find_by(role: :ADMIN)
+    if admin_role.nil?
+      false
+    else
+      user_role.id == admin_role.id
+    end
+  end
+
+
+  def toggle_admin!
+    if is_admin?
+      set_user_role(:USER)
+    else
+      set_user_role(:ADMIN)
+    end
+    save
+  end
+
+
+  def ongoing_extract_requests
+    extract_requests.joins(:extract_statuses).where(extract_statuses: {status: %w[completed enqueued processing email_sent]}).distinct
+  end
+
+
+  def get_ipumsi_user
+    IpumsUser.find_by(email: self.email)
+  end
+
+
+  def set_ipumsi_authentication
+    srand
+    self.ipumsi_salt = Digest::SHA1.hexdigest(rand.to_s)
+    self.ipumsi_crypted_password = Digest::SHA1.hexdigest("#{self.password}:mpc-50wiley:#{self.ipumsi_salt}")
+  end
+
+
+  def ipumsi_authentication_valid?
+    !(self.ipumsi_salt.blank? || self.ipumsi_crypted_password.blank?)
+  end
+
+
+  def normalize_attributes
+    self.firstname.strip!
+    self.lastname.strip!
+    self.email.strip!
+    self.email.downcase!
+    set_user_role(:USER) if self.user_role.nil?
+    set_api_key if self.api_key.nil?
+  end
+
+
+  def set_user_role(role)
+    self.user_role = UserRole.find_by(role: role)
+  end
+
+
+  def set_api_key
+    hash = OpenSSL::Digest::SHA256.new
+    salt = SecureRandom.random_bytes(hash.new.block_length)
+    self.api_key = OpenSSL::HMAC.new(salt, hash).to_s
+  end
+
+
+  def has_valid_agreement?
+    !!(self.opt_in && self.no_fees && self.cite && self.send_copy && self.data_only && self.good_not_evil)
+  end
+
+
+  def has_invalid_agreement?
+    !has_valid_agreement?
+  end
+
+
+  def has_microdata_access?
+    ipumsi_user = get_ipumsi_user
+    !ipumsi_user.nil? && !ipumsi_user.get_ipumsi_registration.nil?
+  end
+
+
+  def microdata_access_is_denied?
+    microdata_access_status == IpumsRegistration::STATUS[:denied]
+  end
+
+
+  def microdata_access_is_pending?
+    microdata_access_status == IpumsRegistration::STATUS[:pending]
+  end
+
+
+  def microdata_access_is_incomplete?
+    microdata_access_status == IpumsRegistration::STATUS[:incomplete]
+  end
+
+
+  def microdata_access_is_approved?
+    !microdata_access_is_expired? && microdata_access_status == IpumsRegistration::STATUS[:approved]
+  end
+
+
+  def microdata_access_is_expired?
+    ipumsi_user = get_ipumsi_user
+    ipumsi_user.nil? and return true
+    ipums_registration = ipumsi_user.get_ipumsi_registration
+    ipums_registration.nil? ? true : ipums_registration.is_expired?
+  end
+
+
+  def microdata_access_expiration_date
+    ipumsi_user = get_ipumsi_user
+    ipumsi_user.nil? and return nil
+    ipums_registration = ipumsi_user.get_ipumsi_registration
+    ipums_registration.nil? ? nil : ipums_registration.expires_at
+  end
+
+
+  def fix_ipumsi_registration
+    return if microdata_access_requested.nil?
+    if !has_microdata_access? && microdata_access_requested && microdata_access_allowed
+      ipumsi_user = get_ipumsi_user
+      registration_data = {
+        id: ipumsi_user.id,
+        address_line_1: address_line_1,
+        address_line_2: address_line_2,
+        address_line_3: address_line_3,
+        city: city,
+        state: state,
+        zip_code: postal_code,
+        country: registration_country,
+        country_of_origin: country_of_origin,
+        phone: personal_phone,
+        department_id: fix_ipumsi_department_id(),
+        academic_status_id: fix_ipumsi_academic_status_id(),
+        anticipated_result_id: fix_ipumsi_anticipated_result_id(),
+        institutional_affiliation: institutional_affiliation,
+        why_no_institution: explain_no_affiliation,
+        institution_name: institution,
+        user_email_at_institution: inst_email,
+        institution_url: inst_web,
+        institution_email: inst_boss,
+        institution_phone: inst_phone,
+        has_safety_board: has_ethics,
+        safety_board_name: ethical_board,
+        research_description: research_description,
+        health_research: health_research,
+        research_funding_source: funder
+      }
+      ipums_registration = IpumsRegistration.new(registration_data)
+      ipums_registration.set_default_creation_attributes
+      ipums_registration.save(validate: false)
+    end
+    reset_microdata_access_info
+  end
+
+
+
+  private
+
+
+  def microdata_access_status
+    ipumsi_user = get_ipumsi_user
+    ipumsi_user.nil? and return nil
+    ipums_registration = ipumsi_user.get_ipumsi_registration
+    ipums_registration.nil? ? nil : ipums_registration.approval_status
+  end
+
+
+  def fix_ipumsi_department_id
+    return nil if field.nil?
+    ipumsi_department = IpumsDepartment.find_by(label: ["academic_#{field}", field.split('_').reverse.join('_')])
+    ipumsi_department.nil? ? nil : ipumsi_department.id
+  end
+
+
+  def fix_ipumsi_academic_status_id
+    return nil if academic_status.nil?
+    ipumsi_academic_status = IpumsAcademicStatus.find_by(web_text: [academic_status.split('_').first.capitalize, "#{academic_status.split('_').first.capitalize} #{academic_status.split('_').last}", "#{academic_status.split('_').first.capitalize}, #{academic_status.split('_').last}"])
+    ipumsi_academic_status.nil? ? nil : ipumsi_academic_status.id
+  end
+
+
+  def fix_ipumsi_anticipated_result_id
+    return nil if research_type.nil?
+    ipumsi_research_type = IpumsAnticipatedResult.find_by(label: research_type) || IpumsAnticipatedResult.find_by(web_text: ["#{research_type.split('_').first.capitalize}, #{research_type.split('_').last}"]) || IpumsAnticipatedResult.find_by("web_text LIKE '#{research_type.split('_').first.capitalize}%'")
+    ipumsi_research_type.nil? ? nil : ipumsi_research_type.id
+  end
+
+
+  def reset_microdata_access_info
+    assign_attributes(Hash[ [
+      :microdata_access_allowed, :microdata_access_requested,
+      :microdata_access_requested_date, :microdata_access_approved_date,
+      :ipumsi_user_id, :address_line_1, :address_line_2, :address_line_3,
+      :city, :state, :postal_code, :registration_country, :country_of_origin,
+      :personal_phone, :explain_no_affiliation, :institution, :inst_email,
+      :inst_web, :inst_boss, :inst_address_line_1, :inst_address_line_2,
+      :inst_address_line_3, :inst_city, :inst_state, :inst_postal_code,
+      :inst_registration_country, :inst_phone, :has_ethics, :ethical_board,
+      :field, :academic_status, :research_type, :research_description,
+      :health_research, :funder, :no_redistribution, :learning_only,
+      :non_commercial, :confidentiality, :secure_data, :scholarly_publication,
+      :discipline, :ipumsi_request_email_sent_at, :institutional_affiliation,
+      :microdata_access_expired_date
+    ].product([nil]) ])
+    save(validate: false)
+  end
+
+
+end

data/app/models/user_role.rb

@@ -0,0 +1,5 @@
+class UserRole < ActiveRecord::Base
+
+  has_many :users
+
+end

data/app/models/variable.rb

@@ -0,0 +1,127 @@
+require 'set'
+
+class Variable < ActiveRecord::Base
+  include MarkupTransform
+
+  has_many :frequencies
+  has_many :categories
+  has_many :sample_variables
+  has_many :samples, through: :sample_variables
+  has_many :area_data_variable_constructions
+  has_many :area_data_variables, through: :area_data_variable_constructions
+  has_many :general_categories, -> { where.not(general_label: '').order(:metadata_id) }, :class_name => 'Category'
+  has_many :detailed_categories, -> { order(:metadata_id) }, :class_name => 'Category'
+  has_many :sample_geog_levels, foreign_key: 'geolink_variable_id'
+  has_many :country_comparabilities, -> { order('countries.full_name').includes(:country) }
+  has_many :variable_availability_caches
+
+  has_and_belongs_to_many :topics
+
+  belongs_to :variable_group
+  belongs_to :sample
+
+  scope :alphabetical, -> { order(mnemonic: :asc) }
+
+  alias_attribute :len, :column_width
+  alias_attribute :width, :column_width
+  alias_attribute :name, :mnemonic
+
+
+  def included_in?(sample)
+    samples.include? sample
+  end
+
+
+  def samples_universes
+    tuples = {}
+    sample_variables.joins(sample: :terrapop_samples).includes(:sample, :universe).find_each{ |sample_variable|
+      tuples[sample_variable.sample.name] = {description: sample_variable.sample.long_description, universe_statement: sample_variable.universe.nil? ? "" : sample_variable.universe.universe_statement}
+    }
+    tuples
+  end
+
+
+  def start
+    if is_svar
+      # belongs to only one sample
+      # Could use the "sample_id" on the variables table but I don't know if the ID in the Samples table is preserved in Terrapop.
+      s = samples.first
+      offset = household_variable? ?  s.offset_for_person : s.offset_for_household
+      column_start + offset
+    else
+      column_start
+    end
+  end
+
+
+  def person_variable?
+    record_type == 'P'
+  end
+
+
+  def household_variable?
+    record_type == 'H'
+  end
+
+
+  def record_type_name
+    household_variable? ? :household : :person
+  end
+
+
+  def data_table_key
+    record_type_name.to_s.pluralize.to_sym
+  end
+
+
+  # returns array of Samples
+  def availability_by_sample
+    samples.select("samples.*, countries.full_name AS country_full_name, UPPER(countries.short_name) AS short_country_name, UPPER(countries.short_name) || lpad((year % 100)::text, 2, '0') AS short_country_name_year").joins("INNER JOIN countries ON samples.country_id = countries.id")
+  end
+
+
+  def availability_by_country
+    cache = variable_availability_caches.first
+    if cache.nil?
+      store = {}
+      _availability_by_country = {}
+      samples.select("samples.*, countries.full_name AS country_full_name").joins("INNER JOIN terrapop_samples ON terrapop_samples.sample_id = samples.id LEFT OUTER JOIN countries ON countries.id = samples.country_id").each do |sample|
+        country_code = sample.country_full_name
+        store[country_code] ||= []
+        store[country_code]<< sample.year
+      end
+      store.each { |key, val| _availability_by_country[key] = val.sort }
+      obj = VariableAvailabilityCach.create(variable_id: id, json: _availability_by_country.to_json)
+      JSON.parse(obj.json)
+    else
+      JSON.parse(cache.json)
+    end
+  end
+
+
+  def country_comparability_for_samples(them_samples)
+    country_comparabilities.where("country_id in (?)", (samples & them_samples).map { |s| s.country }.uniq)
+  end
+
+
+  def description_html
+    transform_markup(description)
+  end
+
+
+  def country_comparability_html(visible_samples)
+    country_comparability_for_samples(visible_samples).to_a
+  end
+
+
+  def general_comparability_html
+    transform_markup(general_comparability)
+  end
+
+
+  def variable_path(str)
+    "<a href='#' class='cross_reference_variables' id='cross_reference_variable_#{str}' data-mnemonic='#{str}'>#{str}</a>"
+  end
+
+
+end

data/app/models/variable_availability_cach.rb

@@ -0,0 +1,3 @@
+class VariableAvailabilityCach < ActiveRecord::Base
+  belongs_to :variable
+end

data/app/models/variable_group.rb

@@ -0,0 +1,14 @@
+class VariableGroup < ActiveRecord::Base
+
+  has_many :variables
+  has_many :children, class_name: "VariableGroup", foreign_key: "parent_id"
+
+  belongs_to :parent, class_name: "VariableGroup", foreign_key: "parent_id"
+
+
+  def rectype_long
+    rectype == 'H' ? 'HOUSEHOLD' : 'PERSON'
+  end
+
+
+end