housing_misc 0.5.4

data/lib/helpers/configuration.rb

@@ -0,0 +1,27 @@
+module Configuration
+
+ def configuration
+  yield self
+ end
+
+ def define_setting(name, default = nil)
+  class_variable_set("@@#{name}", default)
+
+  define_class_method "#{name}=" do |value|
+    class_variable_set("@@#{name}", value)
+  end
+
+  define_class_method name do
+    class_variable_get("@@#{name}")
+  end
+ end
+
+ private
+
+ def define_class_method(name, &block)
+  (class << self; self; end).instance_eval do
+    define_method name, &block
+  end
+ end
+
+end

data/lib/housing_misc.rb

@@ -0,0 +1,31 @@
+
+require 'helpers/configuration'
+module HousingMisc
+  extend Configuration
+
+  define_setting :aws_access_token
+  define_setting :aws_access_secret
+  define_setting :region
+  define_setting :bucket
+  define_setting :origin
+  define_setting :credentials_flag
+  define_setting :expose_headers
+  define_setting :max_age
+  define_setting :sidekiq_custom_threshold, {}
+  define_setting :sidekiq_message_url, "https://hooks.slack.com/services/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"
+  define_setting :app_name
+
+
+  require 'housing_misc/api_helper'
+  require 'housing_misc/engine'
+  require 'housing_misc/slice_helper'
+  require 'housing_misc/json_slice_render'
+  require 'housing_misc/boolean_evaluator'
+  require 'housing_misc/railtie'
+  require 'housing_misc/distance_unit'
+  require 'housing_misc/models_reflections_helper'
+  require 'housing_misc/aerospike_cache_extension'
+  require 'housing_misc/encrypt_decrypt'
+  require 'housing_misc/net_http_generic_request'
+  require 'housing_misc/diff_checker'
+end

data/lib/housing_misc/aerospike_cache_extension.rb

@@ -0,0 +1,100 @@
+require 'connection_pool'
+require 'active_support/cache/aerospike_store'
+module HousingMisc
+  class AerospikeCacheExtension < ActiveSupport::Cache::AerospikeStore
+    READ_WRITE_BATCH_SIZE = 10
+    def initialize(options = {})
+      super
+      aerospike_connection_policy = ::Aerospike::ClientPolicy.new(::JSON.parse(::Figaro.env.aerospike_connection_policy).with_indifferent_access)
+      @conn_pool = ConnectionPool.new(size: 20) { ::Aerospike::Client.new(::JSON.parse(Housing.aerospike_hosts).collect {|host_port| host_port.join(':') }.join(','), policy: aerospike_connection_policy)}
+    end
+
+
+    def read_multi(*names)
+      results = {}
+      aerospike_cache_config = ::JSON.parse(::Figaro.env.aerospike_cache_config)
+      key_list = names.map {|key| Aerospike::Key.new(aerospike_cache_config['namespace'], aerospike_cache_config['set'], key) }
+      @conn_pool.with do |conn|
+        unformatted_rslt = []
+        key_list.each_slice(READ_WRITE_BATCH_SIZE) do |batch_names|
+          unformatted_rslt += conn.batch_get(batch_names)
+        end
+        names.each_with_index do |name, i|
+          if unformatted_rslt[i] != nil
+            results[name] = decrypt_data(unformatted_rslt[i].bins['cache_entry']).value
+          end 
+        end
+      end
+      return results
+    end
+
+    def fetch(key, options=nil)
+      if block_given?
+        if !options.nil? and options[:force] 
+          result = yield
+          write(key, result, options)
+          return result
+        end
+
+        cached_object = read(key, options)
+        return cached_object if cached_object != nil
+
+        result = yield
+        write(key, result, options)
+        return result
+
+      end
+    end
+
+    def fetch_multi(*names)
+      options = names.extract_options!
+      options = merged_options(options)
+      results = read_multi(*names, options)
+      names.map do |name|
+        results.fetch(name) do
+          value = yield name
+          write(name, value, options)
+          results[name] = value
+        end
+      end
+      results
+    end
+
+    def write_multi(hash)
+      hash.each { |key, value| write(key, value.to_json) }
+    end
+
+    protected
+
+    def read_entry(key, options)
+      if value = internal_read_entry(key, options)
+        # if it is not raw it is a marshalled ActiveSupport::Cache::Entry
+        value = options[:raw]? ActiveSupport::Cache::Entry.new(value) : decrypt_data(value)
+      else
+        nil
+      end
+    end
+
+    def write_entry(key, entry, options)
+      options[:expiration] ||= options[:expires_in] if options[:expires_in]
+      options[:record_exists_action] ||= options[:unless_exist]? Aerospike::RecordExistsAction::CREATE_ONLY : Aerospike::RecordExistsAction::REPLACE
+      value = options[:raw]? entry.value : Marshal.dump(entry)
+      begin
+        @client.put(as_key(key, options), {options[:bin] => Zlib::Deflate.deflate(value)}, options)
+      rescue Aerospike::Exceptions::Aerospike => e
+        raise unless (e.result_code == Aerospike::ResultCode::KEY_EXISTS_ERROR)
+        false
+      end
+    end
+
+
+    def decrypt_data(data)
+      begin
+        return nil if data == nil
+        return Marshal.load(Zlib::Inflate.inflate(data))
+      rescue Zlib::DataError => e
+        return nil
+      end
+    end
+  end
+end

data/lib/housing_misc/api_helper.rb

@@ -0,0 +1,239 @@
+module HousingMisc::ApiHelper
+  require 'openssl'
+  MOBILE_REQUEST_TIME_THRESHOLD = 300 #in seconds
+
+  def get_request_attribute_value(headers, params, key)
+    headers["HTTP_#{key.upcase.tr('-', '_')}"] || params[key]
+  end
+
+  def filter_parameters(params)
+    filters = Rails.application.config.filter_parameters rescue []
+    f = ActionDispatch::Http::ParameterFilter.new filters
+    return f.filter(params)
+  end
+
+  def is_request_internal?(request)
+    Rails.env != "production" || request.host.include?("internal")
+  end
+
+  def is_request_from_mobile?(request, params, velocity_salt)
+    source = get_request_attribute_value(request.headers, params, "source") || ""
+    time_stamp = get_request_attribute_value(request.headers, params, "ts")
+    signed_param = get_request_attribute_value(request.headers, params, "sp")
+
+    if time_stamp.blank? || signed_param.blank?
+      if ["android", "ios"].include?(source.downcase) # To be removed once all the users moves to latest app version which includes ts-sp thing
+        log_file ||= Logger.new("#{Rails.root}/log/app_requests_with_missing_params.log")
+        log_invalid_csrf_request(log_file, request, cookies, params)
+         return true 
+      elsif params["app_name"] == "locon.com.datacollection" # To be removed once dc app implements ts-sp thing
+        log_file ||= Logger.new("#{Rails.root}/log/dc_app_requests_with_missing_params.log")
+        log_invalid_csrf_request(log_file, request, cookies, params)
+         return true 
+      end
+    else
+      return ((Time.now.to_i - time_stamp.to_i) <= MOBILE_REQUEST_TIME_THRESHOLD) && (Digest::MD5.hexdigest(velocity_salt + time_stamp) == signed_param)
+    end
+    return false
+  end
+
+  def is_request_csrf_valid?(request, cookies, params, csrf_encryption_key, velocity_salt)
+    if request.get? || is_request_internal?(request) || is_request_from_mobile?(request, params, velocity_salt)
+      return true
+    else
+      csrf_id = cookies["cuid"] || ""
+      csrf_token = request.headers["HTTP_X_CSRF_TOKEN_V2"]
+      return OpenSSL::HMAC.hexdigest(OpenSSL::Digest.new('sha256'), csrf_encryption_key, csrf_id) == csrf_token
+    end
+  end
+
+  def internal_host_check
+    unless is_request_internal?(request)
+      log_file ||= Logger.new("#{Rails.root}/log/unauthorized_api_requests.log")
+      log_file.info "Internal host check violated | remote_ip:#{request.remote_ip}, host:#{request.host}, port:#{request.port}, params:#{filter_parameters(params)}"
+      render :json => {:message => "You are not authorized to make this call"}, status: 401
+    end
+  end
+
+  def csrf_check(csrf_encryption_key, velocity_salt)
+    unless is_request_csrf_valid?(request, cookies, params, csrf_encryption_key, velocity_salt)
+      log_file ||= Logger.new("#{Rails.root}/log/unauthorized_api_requests.log")
+      log_invalid_csrf_request(log_file, request, cookies, params)
+      render :json => {:message => "You are not authorized to make this call", :error => "CSRF_CHECK_FAILED"}, status: 401
+    end
+  end
+
+  def log_invalid_csrf_request(log_file, request, cookies, params)
+    log_file.info "CSRF check violated | new_csrf_token:#{request.headers["HTTP_X_CSRF_TOKEN_V2"]} | new_csrf_id:#{cookies["cuid"]} | remote_ip:#{request.remote_ip} | host:#{request.host} | port:#{request.port} | method:#{request.method} | referrer:#{request.referrer} | User-Agent:#{request.headers["User-Agent"]} | source:#{get_request_attribute_value(request.headers, params, "source")} | time_stamp: #{get_request_attribute_value(request.headers, params, "ts")} | signed_param:#{get_request_attribute_value(request.headers, params, "sp")} | params:#{filter_parameters(params)}"
+  end
+
+  def send_generic_mail(template_slug, template_version, users, base_vars, merge_vars, high_priority=false, attachments=[], deferred=false, send_time=nil, google_analytics_campaign=nil)
+    base_vars = base_vars.with_indifferent_access
+    merge_vars = merge_vars.with_indifferent_access
+    email_template_hash = get_email_template_from_mail_service(template_slug, template_version).with_indifferent_access
+    email_template_hash = add_base_vars(email_template_hash, base_vars)
+    if google_analytics_campaign.present?
+      email_template_hash[:params_json].merge!(google_analytics_campaign: google_analytics_campaign)
+    end
+    email_template_hash = add_user_emails(email_template_hash, users)
+    email_template_hash = add_global_merge_vars(email_template_hash, merge_vars)
+    email_template_hash = add_merge_vars(email_template_hash, merge_vars)
+    email_template_hash = add_attachments(email_template_hash, attachments)
+    if deferred
+      response = Net::HTTP.post_form( URI( "#{Housing.mail_service_url}v1/email/send_deferred" ), "email_request"=> email_template_hash.to_json, "high_priority"=>high_priority, "send_time" => send_time)
+    else
+      response = Net::HTTP.post_form( URI( "#{Housing.mail_service_url}v1/email/send" ), "email_request"=> email_template_hash.to_json, "high_priority"=>high_priority)
+    end
+    return response.code.to_i, response.body
+  end
+
+  def add_base_vars(email_template_hash, base_vars)
+    email_template_hash[:params_json].merge!(base_vars)
+    email_template_hash[:test_email] = Housing.mail_test_id
+    return email_template_hash
+  end
+
+  def add_user_emails(email_template_hash, users)
+    email_template_hash[:params_json][:users] = []
+    users.each do |user_email|
+      user_email = user_email.with_indifferent_access
+      email_template_hash[:params_json][:users].push({name: user_email[:name], email: user_email[:email]})
+    end
+    return email_template_hash
+  end
+
+  def add_global_merge_vars(email_template_hash, vars)
+    email_template_hash[:params_json][:global_merge_vars][:modules].each do |mod_name|
+      mod_name[:merge_vars].first.each do |key, value|
+        mod_name[:merge_vars].first[key] = vars[key] if value.nil?
+      end
+    end
+    return email_template_hash
+  end
+
+  def add_merge_vars(email_template_hash, vars)
+    email_template_hash[:params_json][:merge_vars] = []
+    email_template_hash[:params_json][:users].each do |user_email|
+      email = user_email[:email]
+      email_template_hash[:params_json][:merge_vars].push(email_template_hash[:params_json][:global_merge_vars].merge({email: email}))
+    end
+    if email_template_hash[:params_json][:global_merge_vars][:template_merge_vars].present?
+      email_template_hash[:params_json][:global_merge_vars][:template_merge_vars].each do |key, value|
+        email_template_hash[:params_json][:global_merge_vars][:template_merge_vars][key] = vars[key]
+      end
+    end
+    return email_template_hash
+  end
+
+  def add_attachments(email_template_hash, attachments)
+    email_template_hash[:params_json][:attachments] = attachments if attachments.present?
+    return email_template_hash
+  end
+
+
+  def get_email_template_from_mail_service(template_slug, template_version)
+    template_name = template_slug.gsub("-","_")
+    uri = URI.parse("#{Housing.mail_service_url}v1/email/request_format?template_name=#{template_name}&template_version=#{template_version}")
+    response = (Oj.load(Net::HTTP.get(uri))["data"]) rescue {}
+  end
+
+  def get_past_channel_details(profiles_hash, start_datetime, end_datetime, channel, template_details)
+    response = {}
+    query_params = {
+                    template_name: template_details[:template_name],
+                    end_datetime: end_datetime
+                   }
+    query_params[:template_version] = template_details[:template_version] if channel == "email"
+
+    profiles_date_hash = {}
+    profiles_hash.each do |key, value|
+      date = value["last_activity_time"] || start_datetime
+      date = Date.strptime(date.to_s,'%s').to_time.to_i
+      (profiles_date_hash[date] ||= []) << key
+    end
+
+    profiles_date_hash.each do |date, email_or_numbers|
+      # increasing batch size would lead to exception 414 URI too large, Please don't increase batch size
+      email_or_numbers.each_slice(100) do |batch|
+        query_params[identifier[channel.to_sym]] = batch.join(',')
+        query_params[:start_datetime] = date
+        query = query_params.to_query
+        url = send("#{channel}_report_url".to_sym) + query
+        batch_response = (Oj.load(get_api_call(url))["data"])
+        response.merge!(batch_response)
+      end
+    end
+    response
+  end
+
+  def get_api_call(url, request_timeout = 15.0)
+    parsed_url = URI.parse(url)
+    http = Net::HTTP.new(parsed_url.host, parsed_url.port)
+    http.read_timeout = request_timeout
+    request = Net::HTTP::Get.new(parsed_url.request_uri)
+    begin
+      response = http.request(request)
+      raise "request failed :: #{response}" if response.code != "200"
+      request_response = response.body
+    rescue => exception
+      logging_file.error("CampaignError :: #{exception}")
+      raise "CampaignError for url: #{url}"
+    end
+    return request_response
+  end
+
+  def logging_file
+    @log_file ||= Logger.new("#{Rails.root}/log/campaign_errors.log")
+  end
+
+  def send_generic_sms(phone_number, template_name, send_time, sms_params)
+    post_args ={
+      "template_name" => template_name,
+      "sms_request[number]" => phone_number,
+      "sms_request[test_number]" => Housing.sms_test_number,
+      "send_time" => send_time,
+      "sms_request[params_json]" => sms_params.to_json
+    }
+    response = Net::HTTP.post_form( URI("#{Housing.sms_service_url}/v0/sms/send_deferred"), post_args)
+  end
+
+  def get_shortened_url(url)
+    shortened_url = ""
+    uri = URI.parse("#{Housing.url_shortener}/shorten")
+    response = Net::HTTP.post_form(uri, {url: url})
+    if response.code.to_i == 200
+      shortened_url = Housing.short_url_domain + JSON.parse(response.body)["id"]
+    end
+    shortened_url
+  end
+
+  def upload_log_to_s3(file_path)
+    s3_key = Rails.root.to_s.split('/')[-1] + '/' + file_path.split('/')[-1]
+    s3_client.bucket(HousingMisc.bucket).object(s3_key).upload_file(file_path)
+  end
+
+  private
+
+  def email_report_url
+    "#{Housing.mail_service_url}/api/v1/email-report?"
+  end
+
+  def sms_report_url
+    "#{Housing.sms_service_url}/v0/sms-report?"
+  end
+
+  def identifier
+    {
+      email: :emails,
+      sms: :phone_numbers
+    }
+  end
+
+  def s3_client
+    @s3_client ||= Aws::S3::Resource.new(
+      credentials: Aws::Credentials.new(HousingMisc.aws_access_token, HousingMisc.aws_access_secret),
+      region: HousingMisc.region
+    )
+  end
+
+end

data/lib/housing_misc/boolean_evaluator.rb

@@ -0,0 +1,7 @@
+module BooleanEvaluator
+  def self.eval(val)
+    return true if val == true || val.to_s =~ (/^(true|t|yes|y|1|on)$/i)
+    return false if val == false || val.nil? || val.to_s =~ (/^(false|f|no|n|0|off)$/i)
+    raise ArgumentError.new("invalid value for Boolean: \"#{val}\"")
+  end
+end

data/lib/housing_misc/diff_checker.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'json'
+
+# DiffChecker module is used to compare diff among
+# application.yml application.yml.sample and default.rb.
+module DiffChecker
+
+  def self.check_diff(deployment_file_path, sample_file_path, default_rb_file)
+    content = YAML.safe_load(File.read(deployment_file_path))
+    content_sample = YAML.safe_load(File.read(sample_file_path))
+    raise "#{sample_file_path} cant be empty" if (content_sample.nil? || content_sample.empty?)
+    missing_keys = content.nil? ? content_sample.keys : content_sample.keys - content.keys
+    unless missing_keys.empty?
+      raise "Some keys are missing in application.yml, but present in application.yml.sample. missing_keys : #{missing_keys}"
+    end
+    default_content_type1 = File.readlines(default_rb_file)
+                                .map{ |line| line.match(/Figaro.env.[a-z0-9\_\-]+/).to_s.split('.')[2]}.reject{|line| line.nil?}
+    default_content_type2 = File.readlines(default_rb_file)
+                                .map{ |line| line.match(/Figaro.env[^\.\s]+/).to_s.match(/[\"\'][a-z]*[^\]]+/)
+                                            .to_s.gsub!(/\A"|"\Z/, '')}.reject{|line| line.nil?}
+    default_file_keys = default_content_type1 + default_content_type2
+    missing_keys = content.nil? ? default_file_keys : default_file_keys - content.keys
+    unless missing_keys.empty?
+      raise "Some keys are missing in application.yml, but present in default.rb. missing_keys : #{missing_keys}"
+    end
+  end
+end
+

data/lib/housing_misc/distance_unit.rb

@@ -0,0 +1,140 @@
+METRIC_PREFIXES = {milli: 10**-3, centi: 10**-2, deci: 10**-1, '': 1, deka: 10**1, hecto: 10**2, kilo: 10**3}
+IMPERIAL_UNITS = {inches: 12**-1, feet: 1, yards: 3, miles: 5280}
+DIMENSIONS = {'': 1, square_: 2, cubic_: 3}
+FEET_TO_METRES_CONVERSION = 0.3048
+
+require 'active_support/inflector'
+
+Numeric.class_eval do
+  DIMENSIONS.each do |dimension_prefix, dimension|
+    METRIC_PREFIXES.keys.each do|prefix|
+      define_method("#{dimension_prefix}#{prefix}metres") do
+        distance_ob = MetricDistance.new(self, prefix.intern, dimension, dimension_prefix)
+        return distance_ob
+      end
+      alias_method "#{dimension_prefix}#{prefix}metre".intern, "#{dimension_prefix}#{prefix}metres".intern
+    end
+  end
+
+  DIMENSIONS.each do |dimension_prefix, dimension|
+    IMPERIAL_UNITS.keys.each do |base_unit|
+      define_method("#{dimension_prefix}#{base_unit}") do
+        distance_ob = ImperialDistance.new(self, base_unit, dimension, dimension_prefix)
+        return distance_ob
+      end
+      alias_method "#{dimension_prefix}#{base_unit.to_s.singularize}".intern, "#{dimension_prefix}#{base_unit}".intern
+    end
+    alias_method "#{dimension_prefix}foot".intern, "#{dimension_prefix}feet".intern
+  end
+
+end
+
+class DistanceUnit < Numeric
+
+  attr_reader :dimension, :dimension_prefix
+  attr_accessor :value, :base_unit
+
+  def initialize value, base_unit, dimension, dimension_prefix
+    @value = value
+    @base_unit = base_unit
+    @dimension = dimension
+    @dimension_prefix = dimension_prefix
+  end
+
+  def format_display
+    display_string = ''
+    base_distance = self.to_metres
+    if base_distance.value >= 1000
+      display_string = "#{base_distance.to_kilometres.value.round(1)} km"
+    else
+      display_string = "#{base_distance.value.round(0)} m"
+    end
+    return display_string
+  end
+
+  def unit
+    return "#{self.dimension_prefix}#{self.base_unit}"
+  end
+
+  def value
+    return @value.to_f
+  end
+
+  DIMENSIONS.each do |dimension_prefix, dimension|
+    METRIC_PREFIXES.each do |prefix, scale|
+      define_method("to_#{dimension_prefix}#{prefix}metres") do
+        raise "Dimension Error" if self.dimension != dimension
+        base_imperial = self.send("to_#{dimension_prefix}feet")
+        metric_value = base_imperial.value * (FEET_TO_METRES_CONVERSION ** dimension)
+        base_metric = MetricDistance.new(metric_value, '', dimension, dimension_prefix)
+        metric_distance = base_metric.send("to_#{dimension_prefix}#{prefix}metres")
+      end
+      alias_method "to_#{dimension_prefix}#{prefix}metre".intern, "to_#{dimension_prefix}#{prefix}metres".intern
+    end
+  end
+
+  DIMENSIONS.each do |dimension_prefix, dimension|
+    IMPERIAL_UNITS.each do |base_unit, scale|
+      define_method("to_#{dimension_prefix}#{base_unit}") do
+        raise "Dimension Error" if self.dimension != dimension
+        base_metric = self.send("to_#{dimension_prefix}metres")
+        imperial_value = base_metric.value * (FEET_TO_METRES_CONVERSION ** -dimension)
+        base_imperial = ImperialDistance.new(imperial_value, :feet, dimension, dimension_prefix)
+        imperial_distance = base_imperial.send("to_#{dimension_prefix}#{base_unit}")
+      end
+      alias_method "to_#{dimension_prefix}#{base_unit.to_s.singularize}".intern, "to_#{dimension_prefix}#{base_unit}".intern
+    end
+    alias_method "to_#{dimension_prefix}foot".intern, "to_#{dimension_prefix}feet".intern
+  end
+
+end
+
+class MetricDistance < DistanceUnit
+
+  attr_accessor :metric_prefix
+
+  def initialize value, metric_prefix, dimension, dimension_prefix
+    @metric_prefix = metric_prefix
+    base_unit = "#{metric_prefix}metres".intern
+    super(value, base_unit, dimension, dimension_prefix)
+  end
+
+  def metric_prefix= metric_prefix
+    self.metric_prefix = metric_prefix
+    self.base_unit = "#{metric_prefix}metres".intern
+  end
+
+  DIMENSIONS.each do |dimension_prefix, dimension|
+    METRIC_PREFIXES.each do |prefix, scale|
+      define_method("to_#{dimension_prefix}#{prefix}metres") do
+        raise "Dimension Error" if self.dimension != dimension
+        current_value = self.value
+        current_prefix = self.metric_prefix
+        new_value = current_value * ((METRIC_PREFIXES[current_prefix.intern] * (scale**-1)) ** dimension)
+        return MetricDistance.new(new_value, prefix.intern, dimension, dimension_prefix)
+      end
+      alias_method "to_#{dimension_prefix}#{prefix}metre".intern, "to_#{dimension_prefix}#{prefix}metres".intern
+    end
+  end
+
+end
+
+class ImperialDistance < DistanceUnit
+
+  DIMENSIONS.each do |dimension_prefix, dimension|
+    IMPERIAL_UNITS.each do |base_unit, scale|
+      define_method("to_#{dimension_prefix}#{base_unit}") do
+        raise "Dimension Error" if self.dimension != dimension
+        current_value = self.value
+        current_unit = self.base_unit
+        new_value = current_value * ((IMPERIAL_UNITS[current_unit.intern] * (scale**-1)) ** dimension)
+        return ImperialDistance.new(new_value, base_unit, dimension, dimension_prefix)
+      end
+      alias_method "to_#{dimension_prefix}#{base_unit.to_s.singularize}".intern, "to_#{dimension_prefix}#{base_unit}".intern
+    end
+    alias_method "to_#{dimension_prefix}foot".intern, "to_#{dimension_prefix}feet".intern
+  end
+
+end
+
+