zuora_connect_oauth_alpha 2

data/db/migrate/20100718151733_create_connect_app_instances.rb

@@ -0,0 +1,9 @@
+class CreateConnectAppInstances < ActiveRecord::Migration
+  def change
+    if !ActiveRecord::Base.connection.table_exists?('zuora_connect_app_instances')
+      create_table :zuora_connect_app_instances do |t|
+        t.timestamps null: false
+      end
+    end
+  end
+end

data/db/migrate/20101024162319_add_tokens_to_app_instance.rb

@@ -0,0 +1,6 @@
+class AddTokensToAppInstance < ActiveRecord::Migration
+  def change
+    add_column :zuora_connect_app_instances, :access_token, :string unless column_exists? :zuora_connect_app_instances, :access_token
+    add_column :zuora_connect_app_instances, :refresh_token, :string unless column_exists? :zuora_connect_app_instances, :refresh_token
+  end
+end

data/db/migrate/20101024220705_add_token_to_app_instance.rb

@@ -0,0 +1,5 @@
+class AddTokenToAppInstance < ActiveRecord::Migration
+  def change
+    add_column :zuora_connect_app_instances, :token, :string  unless column_exists? :zuora_connect_app_instances, :token
+  end
+end

data/db/migrate/20110131211919_add_sessions_table.rb

@@ -0,0 +1,13 @@
+class AddSessionsTable < ActiveRecord::Migration
+  def change
+    if !ActiveRecord::Base.connection.table_exists?('sessions')
+      create_table :sessions do |t|
+        t.string :session_id, :null => false
+        t.text :data
+        t.timestamps
+      end
+      add_index :sessions, :session_id, :unique => true
+      add_index :sessions, :updated_at
+    end
+  end
+end

data/db/migrate/20110411200303_add_expiration_to_app_instance.rb

@@ -0,0 +1,5 @@
+class AddExpirationToAppInstance < ActiveRecord::Migration
+  def change
+    add_column :zuora_connect_app_instances, :oauth_expires_at, :datetime  unless column_exists? :zuora_connect_app_instances, :oauth_expires_at
+  end
+end

data/db/migrate/20110413191512_add_new_api_token.rb

@@ -0,0 +1,5 @@
+class AddNewApiToken < ActiveRecord::Migration
+  def change
+    add_column :zuora_connect_app_instances, :api_token, :string  unless column_exists? :zuora_connect_app_instances, :api_token
+  end
+end

data/db/migrate/20110503003602_add_catalog_data_to_app_instance.rb

@@ -0,0 +1,6 @@
+class AddCatalogDataToAppInstance < ActiveRecord::Migration
+  def change
+    add_column :zuora_connect_app_instances, :catalog_updated_at, :datetime  unless column_exists? :zuora_connect_app_instances, :catalog_updated_at
+    add_column :zuora_connect_app_instances, :catalog, :jsonb, default: {}  unless column_exists? :zuora_connect_app_instances, :catalog
+  end
+end

data/db/migrate/20110503003603_add_catalog_mappings_to_app_instance.rb

@@ -0,0 +1,5 @@
+class AddCatalogMappingsToAppInstance < ActiveRecord::Migration
+  def change
+    add_column :zuora_connect_app_instances, :catalog_mapping, :jsonb, default: {} unless column_exists? :zuora_connect_app_instances, :catalog_mapping
+  end
+end

data/db/migrate/20110503003604_catalog_default.rb

@@ -0,0 +1,5 @@
+class CatalogDefault < ActiveRecord::Migration
+  def change
+    change_column :zuora_connect_app_instances, :catalog, :jsonb, default: {}
+  end
+end

data/db/migrate/20180301052853_add_catalog_attempted_at.rb

@@ -0,0 +1,5 @@
+class AddCatalogAttemptedAt < ActiveRecord::Migration
+  def change
+    add_column :zuora_connect_app_instances, :catalog_update_attempt_at, :datetime  unless column_exists? :zuora_connect_app_instances, :catalog_update_attempt_at
+  end
+end

data/lib/resque/additions.rb

@@ -0,0 +1,53 @@
+module Resque
+  module Additions
+    def dequeue_from(queue, klass, *args)
+      ####### ------ Resque Job --------
+      # Perform before_dequeue hooks. Don't perform dequeue if any hook returns false
+      before_hooks = Plugin.before_dequeue_hooks(klass).collect do |hook|
+        klass.send(hook, *args)
+      end
+      return if before_hooks.any? { |result| result == false }
+
+      destroyed = Job.destroy(queue, klass, *args)
+
+      Plugin.after_dequeue_hooks(klass).each do |hook|
+        klass.send(hook, *args)
+      end
+
+      destroyed
+    end
+    
+    ####### ------ Resque Delayed Job --------
+    # Returns delayed jobs schedule timestamp for +klass+, +args+.
+    def scheduled_at_with_queue(queue, klass, *args)
+      search = encode(job_to_hash_with_queue(queue,klass, args))
+      redis.smembers("timestamps:#{search}").map do |key|
+        key.tr('delayed:', '').to_i
+      end
+    end
+
+    # Given an encoded item, remove it from the delayed_queue
+    def remove_delayed_with_queue(queue, klass, *args)
+      search = encode(job_to_hash_with_queue(queue,klass, args))
+      remove_delayed_job(search)
+    end
+
+    #Given a timestamp and job (klass + args) it removes all instances and
+    # returns the count of jobs removed.
+    #
+    # O(N) where N is the number of jobs scheduled to fire at the given
+    # timestamp
+    def remove_delayed_job_with_queue_from_timestamp(timestamp, queue, klass, *args)
+      return 0 if Resque.inline?
+
+      key = "delayed:#{timestamp.to_i}"
+      encoded_job = encode(job_to_hash_with_queue(queue, klass, args))
+
+      redis.srem("timestamps:#{encoded_job}", key)
+      count = redis.lrem(key, 0, encoded_job)
+      clean_up_timestamp(key, timestamp)
+
+      count
+    end
+  end
+end

data/lib/resque/dynamic_queues.rb

@@ -0,0 +1,131 @@
+module Resque
+  module DynamicQueues
+    def filter_busy_queues qs
+      busy_queues = Resque::Worker.working.map { |worker| worker.job["queue"] }.compact
+      Array(qs.dup).compact - busy_queues
+    end
+
+    def rotated_queues
+      @n ||= 0
+      @n += 1
+      rot_queues = queues # since we rely on the resque-dynamic-queues plugin, this is all the queues, expanded out
+      if rot_queues.size > 0
+        @n = @n % rot_queues.size
+        rot_queues.rotate(@n)
+      else
+        rot_queues
+      end
+    end
+
+    def queue_depth queuename
+      busy_queues = Resque::Worker.working.map { |worker| worker.job["queue"] }.compact
+      # find the queuename, count it.
+      busy_queues.select {|q| q == queuename }.size
+    end
+
+    DEFAULT_QUEUE_DEPTH = 0
+    def should_work_on_queue? queuename
+      return true if @queues.include? '*'  # workers with QUEUES=* are special and are not subject to queue depth setting
+      max = DEFAULT_QUEUE_DEPTH
+      unless ENV["RESQUE_QUEUE_DEPTH"].nil? || ENV["RESQUE_QUEUE_DEPTH"] == ""
+        max = ENV["RESQUE_QUEUE_DEPTH"].to_i
+      end
+      return true if max == 0 # 0 means no limiting
+      cur_depth = queue_depth(queuename)
+      log! "queue #{queuename} depth = #{cur_depth} max = #{max}"
+      return true if cur_depth < max
+      false
+    end
+
+    def reserve_with_round_robin
+      qs = rotated_queues
+      qs.each do |queue|
+        log! "Checking #{queue}"
+        if should_work_on_queue?(queue) && @job_in_progress = Resque::Job.reserve(queue)
+          log! "Found job on #{queue}"
+          return @job_in_progress
+        end
+        # Start the next search at the queue after the one from which we pick a job.
+        @n += 1
+      end
+
+      nil
+    rescue Exception => e
+      log "Error reserving job: #{e.inspect}"
+      log e.backtrace.join("\n")
+      raise e
+    end
+
+    # Returns a list of queues to use when searching for a job.
+    #
+    # A splat ("*") means you want every queue (in alpha order) - this
+    # can be useful for dynamically adding new queues.
+    #
+    # The splat can also be used as a wildcard within a queue name,
+    # e.g. "*high*", and negation can be indicated with a prefix of "!"
+    #
+    # An @key can be used to dynamically look up the queue list for key from redis.
+    # If no key is supplied, it defaults to the worker's hostname, and wildcards
+    # and negations can be used inside this dynamic queue list.   Set the queue
+    # list for a key with Resque.set_dynamic_queue(key, ["q1", "q2"]
+    #
+    def queues_with_dynamic
+      queue_names = @queues.dup
+      
+      return queues_without_dynamic if queue_names.grep(/(^!)|(^@)|(\*)/).size == 0
+
+      real_queues = Resque.queues
+      matched_queues = []
+
+      #Remove Queues under Api Limits
+      api_limit_instances = Redis.current.keys('APILimits:*').map {|key| key.split('APILimits:').last.to_i}
+      real_queues = real_queues.select {|key| key if !api_limit_instances.include?((key.match(/^(\d*)_.*/) || [])[1].to_i)}
+      
+      #Queue Pausing 
+      paused_instances = Redis.current.keys('resque:PauseQueue:*').map {|key| key.split('resque:PauseQueue:').last.to_i}
+      real_queues = real_queues.select {|key| key if !paused_instances.include?((key.match(/^(\d*)_.*/) || [])[1].to_i)}
+
+      while q = queue_names.shift
+        q = q.to_s
+
+        if q =~ /^(!)?@(.*)/
+          key = $2.strip
+          key = hostname if key.size == 0
+
+          add_queues = Resque.get_dynamic_queue(key)
+          add_queues.map! { |q| q.gsub!(/^!/, '') || q.gsub!(/^/, '!') } if $1
+
+          queue_names.concat(add_queues)
+          next
+        end
+
+        if q =~ /^!/
+          negated = true
+          q = q[1..-1]
+        end
+
+        patstr = q.gsub(/\*/, '.*')
+        pattern = /^#{patstr}$/
+        if negated
+          matched_queues -= matched_queues.grep(pattern)
+        else
+          matches = real_queues.grep(/^#{pattern}$/)
+          matches = [q] if matches.size == 0 && q == patstr
+          matched_queues.concat(matches.sort)
+        end
+      end
+     
+      return matched_queues.uniq
+    end
+
+
+    def self.included(receiver)
+      receiver.class_eval do
+        alias queues_without_dynamic queues
+        alias queues queues_with_dynamic
+        alias reserve_without_round_robin reserve
+        alias reserve reserve_with_round_robin
+      end
+    end
+  end
+end

data/lib/resque/self_lookup.rb

@@ -0,0 +1,19 @@
+module Resque
+  module SelfLookup
+    def payload_class_enhanced
+      @payload_class ||= constantize(@payload['class'])
+      @payload_class.instance_eval { class << self; self end }.send(:attr_accessor, :worker)
+      @payload_class.instance_eval { class << self; self end }.send(:attr_accessor, :job)
+      @payload_class.worker =  self.worker
+      @payload_class.job =  self
+      return @payload_class
+    end
+
+    def self.included(receiver)
+      receiver.class_eval do
+        alias payload_class_old payload_class
+        alias payload_class payload_class_enhanced
+      end
+    end
+  end
+end

data/lib/tasks/zuora_connect_tasks.rake

@@ -0,0 +1,24 @@
+# desc "Explaining what the task does"
+# task :connect do
+#   # Task goes here
+# end
+
+namespace :db do
+  desc 'Also create shared_extensions Schema'
+  task :extensions => :environment  do
+    # Create Schema
+    ActiveRecord::Base.connection.execute 'CREATE SCHEMA IF NOT EXISTS shared_extensions;'
+    # Enable Hstore
+    ActiveRecord::Base.connection.execute 'CREATE EXTENSION IF NOT EXISTS HSTORE SCHEMA shared_extensions;'
+    # Enable UUID-OSSP
+    ActiveRecord::Base.connection.execute 'CREATE EXTENSION IF NOT EXISTS "uuid-ossp" SCHEMA shared_extensions;'
+  end
+end
+
+Rake::Task["db:create"].enhance do
+  Rake::Task["db:extensions"].invoke
+end
+
+Rake::Task["db:test:purge"].enhance do
+  Rake::Task["db:extensions"].invoke
+end

data/lib/zuora_connect_oauth_alpha.rb

@@ -0,0 +1,38 @@
+require 'zuora_connect_oauth_alpha/configuration'
+require "zuora_connect_oauth_alpha/engine"
+require 'zuora_connect_oauth_alpha/exceptions'
+require 'zuora_connect_oauth_alpha/controllers/helpers'
+require 'zuora_connect_oauth_alpha/views/helpers'
+require 'zuora_connect_oauth_alpha/railtie'
+require 'resque/additions' 
+require 'resque/dynamic_queues'
+require 'resque/self_lookup'
+
+module ZuoraConnect
+  class << self
+    attr_accessor :configuration
+  end
+  module Controllers
+    autoload :Helpers,        'zuora_connect_oauth_alpha/controllers/helpers'
+  end
+
+  module Views
+    ActionView::Base.send(:include, Helpers)
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.reset
+    @configuration = Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+    ::Apartment.excluded_models << "Delayed::Job" if configuration.delayed_job
+    ::Apartment.excluded_models.concat(configuration.additional_apartment_models) if configuration.additional_apartment_models.class == Array
+
+    return configuration
+  end
+end

data/lib/zuora_connect_oauth_alpha/configuration.rb

@@ -0,0 +1,40 @@
+module ZuoraConnect
+  class Configuration
+    attr_accessor :oauth_client_id, :oauth_client_secret, :oauth_client_redirect_uri,:use_s3, :default_locale,:dev_mode_appinstance ,:dev_mode_admin, :dev_mode_user, :dev_mode_pass, :default_time_zone,:delayed_job,:url, :private_key, :dev_mode_logins,:dev_mode_mode, :dev_mode_options, :mode, :timeout,:dev_mode_secret_access_key,:dev_mode_access_key_id,:aws_region, :s3_bucket_name, :s3_folder_name, :additional_apartment_models
+
+    def initialize
+      @default_locale = :en
+      @default_time_zone = Time.zone
+      @url = "https://connect.zuora.com"
+      @mode = "Production"
+      @delayed_job = false
+      @use_s3 = false
+      @private_key = ENV["CONNECT_KEY"]
+      @additional_apartment_models = []
+
+      # OAuth Settings
+      @oauth_client_id = ""
+      @oauth_client_secret = ""
+      @oauth_client_redirect_uri = "https://connect.zuora.com/"
+
+      # DEV MODE OPTIONS
+      @dev_mode_logins = { "target_login" => {"tenant_type" => "Zuora", "username" => "user", "password" => "pass", "url" => "url"} }
+      @dev_mode_options = {"name" => {"config_name" => "name", "datatype" => "type", "value" => "value"}}
+      @dev_mode_mode = "Universal"
+      @dev_mode_appinstance = "1"
+      @dev_mode_user = "test"
+      @dev_mode_pass = "test"
+      @dev_mode_admin = false
+      @dev_mode_secret_access_key = nil
+      @dev_mode_access_key_id = nil
+      @aws_region = "us-west-2"
+      @s3_bucket_name = "rbm-apps"
+      @s3_folder_name = Rails.application.class.parent_name
+    end
+
+    def private_key
+      raise "Private Key Not Set" if @private_key.blank?
+      @private_key.include?("BEGIN") ? @private_key : Base64.urlsafe_decode64(@private_key)
+    end
+  end
+end

data/lib/zuora_connect_oauth_alpha/controllers/helpers.rb

@@ -0,0 +1,165 @@
+require 'apartment/migrator'
+module ZuoraConnect
+  module Controllers
+    module Helpers
+      extend ActiveSupport::Concern
+
+      def authenticate_app_api_request
+        #Skip session for api requests
+        request.session_options[:skip] = true
+        start_time = Time.now
+        if request.headers["API-Token"].present?
+          @appinstance = ZuoraConnect::AppInstance.where(:api_token => request.headers["API-Token"]).first
+          Rails.logger.debug("[#{@appinstance.id}] API REQUEST - API token") if @appinstance.present?
+          check_instance
+        else
+          authenticate_or_request_with_http_basic do |username, password|
+            @appinstance = ZuoraConnect::AppInstance.where(:token => password).first
+            @appinstance ||= ZuoraConnect::AppInstance.where(:api_token => password).first
+            Rails.logger.debug("[#{@appinstance.id}] API REQUEST - Basic Auth") if @appinstance.present?
+            check_instance
+          end
+        end
+        Rails.logger.info("[#{@appinstance.blank? ? "N/A" : @appinstance.id}] Authenticate App API Request Completed In - #{(Time.now - start_time).round(2)}s")
+      end
+
+      def authenticate_connect_app_request
+        start_time = Time.now
+
+        if ZuoraConnect.configuration.mode == "Production"
+          if request["data"]
+            setup_instance_via_data
+          else
+            setup_instance_via_session
+          end
+        else
+          setup_instance_via_dev_mode
+        end
+        #Call .data_lookup with the current session to retrieve session. In some cases session may be stored/cache in redis 
+        #so data lookup provides a model method that can be overriden per app.
+        if params[:controller] != 'zuora_connect/api/v1/app_instance' && params[:action] != 'drop'
+          if @appinstance.new_session_for_ui_requests(:params => params)
+            @appinstance.new_session(:session => @appinstance.data_lookup(:session => session))
+          end
+        end
+        PaperTrail.whodunnit =  session["#{@appinstance.id}::user::email"] if defined?(PaperTrail) && session["#{@appinstance.id}::user::email"].present? 
+        begin
+          I18n.locale = session["#{@appinstance.id}::user::locale"] ?  session["#{@appinstance.id}::user::locale"] : @appinstance.locale
+        rescue I18n::InvalidLocale => ex
+          Rails.logger.error("Invalid Locale: #{ex.message}")
+        end
+        Time.zone = session["#{@appinstance.id}::user::timezone"] ? session["#{@appinstance.id}::user::timezone"] : @appinstance.timezone
+        Rails.logger.info("[#{@appinstance.blank? ? "N/A" : @appinstance.id}] Authenticate App Request Completed In - #{(Time.now - start_time).round(2)}s")
+      end
+
+      def persist_connect_app_session
+        if @appinstance.present?
+          if defined?(Redis.current)
+            @appinstance.cache_app_instance
+          else
+            session.merge!(@appinstance.save_data)
+          end
+        end
+      end
+
+      def check_connect_admin!
+        raise ZuoraConnect::Exceptions::AccessDenied.new("User is not an authorized admin for this application") if !session["#{@appinstance.id}::admin"]
+      end
+
+      def check_connect_admin
+        return session["#{@appinstance.id}::admin"]
+      end
+
+    private
+      def setup_instance_via_data
+        session.clear
+        values = JSON.parse(ZuoraConnect::AppInstance.decrypt_response(Base64.urlsafe_decode64(request["data"])))
+        Rails.logger.debug("Data: #{values.to_json}")
+        if values["param_data"]
+          values["param_data"].each do |k ,v|
+            params[k] = v
+          end
+        end
+        session["#{values["appInstance"]}::destroy"] = values["destroy"]
+        session["appInstance"] = values["appInstance"]
+        if values["current_user"]
+          session["#{values["appInstance"]}::admin"] = values["current_user"]["admin"] ? values["current_user"]["admin"] : false
+          session["#{values["appInstance"]}::user::timezone"] = values["current_user"]["timezone"]
+          session["#{values["appInstance"]}::user::locale"] = values["current_user"]["locale"]
+          session["#{values["appInstance"]}::user::email"] = values["current_user"]["email"]
+        end
+
+        Rails.logger.debug("App Params: #{values.to_json}}") if Rails.env != "production"
+
+        @appinstance = ZuoraConnect::AppInstance.where(:id => values["appInstance"].to_i).first
+        if @appinstance.blank?
+          Apartment::Tenant.switch!("public")
+          begin
+            Apartment::Tenant.create(values["appInstance"].to_s)
+          rescue Apartment::TenantExists => ex
+            Rails.logger.debug("Tenant Already Exists")
+          end
+          @appinstance = ZuoraConnect::AppInstance.new(:api_token =>  values[:api_token],:id => values["appInstance"].to_i, :access_token => values["access_token"].blank? ? values["user"] : values["access_token"], :token => values["refresh_token"]  , :refresh_token => values["refresh_token"].blank? ? values["key"] : values["refresh_token"], :oauth_expires_at => values["expires"])
+          @appinstance.save(:validate => false)
+        else
+          @appinstance.access_token = values["access_token"] if !values["access_token"].blank? && @appinstance.access_token != values["access_token"]
+          @appinstance.refresh_token = values["refresh_token"] if !values["refresh_token"].blank? && @appinstance.refresh_token != values["refresh_token"]
+          @appinstance.oauth_expires_at = values["expires"] if !values["expires"].blank?
+          @appinstance.api_token = values["api_token"] if !values["api_token"].blank? && @appinstance.api_token != values["api_token"]
+          if @appinstance.access_token_changed? && @appinstance.refresh_token_changed?
+            @appinstance.save(:validate => false)
+          else
+            raise ZuoraConnect::Exceptions::AccessDenied.new("Authorization mistmatch. Possible tampering")
+          end
+        end     
+      end
+
+      def setup_instance_via_session
+        if session["appInstance"].present?
+          @appinstance = ZuoraConnect::AppInstance.where(:id => session["appInstance"]).first
+        else
+          raise ZuoraConnect::Exceptions::SessionInvalid.new("Session Blank -- Relaunch Application")
+        end
+      end
+
+      def setup_instance_via_dev_mode
+        session["appInstance"] = ZuoraConnect.configuration.dev_mode_appinstance
+        user = ZuoraConnect.configuration.dev_mode_user
+        key = ZuoraConnect.configuration.dev_mode_pass
+        values = {:user => user , :key => key, :appinstance => session["appInstance"]}
+        @appinstance = ZuoraConnect::AppInstance.where(:id => values[:appinstance].to_i).first
+        if @appinstance.blank?
+          puts "make new!"
+          Apartment::Tenant.switch!("public")
+          begin
+            Apartment::Tenant.create(values[:appinstance].to_s)
+          rescue Apartment::TenantExists => ex
+            Apartment::Tenant.drop(values[:appinstance].to_s)
+            retry
+          end
+
+          @appinstance = ZuoraConnect::AppInstance.new(:id => values[:appinstance].to_i, :access_token => values[:user], :refresh_token => values[:key], :token => "#{values[:key]}#{values[:key]}", :api_token => "#{values[:key]}#{values[:key]}")
+          @appinstance.save(:validate => false)
+        end
+        if @appinstance.access_token.blank? || @appinstance.refresh_token.blank? || @appinstance.token.blank? || @appinstance.api_token.blank?
+          @appinstance.update_attributes!(:access_token =>  values["user"], :refresh_token =>  values["key"], :token => "#{values[:key]}#{values[:key]}", :api_token => "#{values[:key]}#{values[:key]}")
+        end
+        session["#{@appinstance.id}::admin"] =  ZuoraConnect.configuration.dev_mode_admin
+      end
+
+      #API ONLY
+      def check_instance
+        if @appinstance.present?
+          if @appinstance.new_session_for_api_requests(:params => params)
+            @appinstance.new_session(:session => @appinstance.data_lookup(:session => session))
+          end
+          Thread.current[:appinstance] = @appinstance
+          PaperTrail.whodunnit = "API User" if defined?(PaperTrail)
+          return true
+        else
+          render text: "Access Denied", status: :unauthorized
+        end
+      end
+    end
+  end
+end