zuora_connect 2.1.1 → 3.0.0.pre.a

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0342c5ac7396b4e8ba75aff8dbab5d579fa6d0ad04a421b7d1d809ab3abbd90a
-  data.tar.gz: 70f7277a93fec8e481f63e56f85e466b5e0b4d1307e2413e4f8da9497e980be2
+  metadata.gz: e63c10c8405375ad7cb2c28073c6181ed055266fb8d61e3ac5725e8f5b8ca8d5
+  data.tar.gz: c5124fe3590fd14c0acdad0cfe6e567997195eaa728245f620bfff5bbda285fe
 SHA512:
-  metadata.gz: eb6497a343dde2b4a3edfe470c8e5a44eb37ff99b75ed434138c280e8ac25bf36806d58fbb477772182596917f1c37c0e237bd55e88f646e149743477fba2f15
-  data.tar.gz: f0b1f8b6f647f204ce8c4bfed7a8e77b49f3aada0faf6a0c31fc47675f5bfca67feb464692006bcb490977a577d1d5a3feab53886815f4c6472023e9ade6823b
+  metadata.gz: 1beb3e3c0531b3035051711670de269814122c20269086ffd31257b02dc4e6ff8c515ac812abc436360ebc9f1506e3ae8e15e859d6098913e08f2dfed67e1284
+  data.tar.gz: bff9fca90e302be4fe97b3cac4ac54bb8dc6c841ad6762939f9b0b2c6c7e66417bb108105d6d8372965ae9090d813c97cff8a4a4a6b513665beed63c9229f0e4

data/app/controllers/zuora_connect/static_controller.rb

@@ -1,23 +1,20 @@
 module ZuoraConnect
   class StaticController < ApplicationController
-    before_action :authenticate_connect_app_request, :except => [:metrics, :health, :initialize_app]
-    before_action :clear_connect_app_session,        :only =>   [:metrics, :health, :initialize_app]
-    after_action :persist_connect_app_session,       :except => [:metrics, :health, :initialize_app]
-    
-    skip_before_action :verify_authenticity_token, :only => [:initialize_app]
-
-    def metrics
-      type = params[:type].present? ? params[:type] : "versions"
-      render json: ZuoraConnect::AppInstance.get_metrics(type).to_json, status: 200
-    end
+    before_action :authenticate_connect_app_request, :except => [:health, :initialize_app, :provision, :instance_user]
+    before_action :clear_connect_app_session,        :only =>   [:health, :initialize_app, :provision, :instance_user]
+    after_action :persist_connect_app_session,       :except => [:health, :initialize_app, :provision, :instance_user]
+
+    skip_before_action :verify_authenticity_token, :only => [:initialize_app, :provision]
+    http_basic_authenticate_with name: ENV['PROVISION_USER'], password: ENV['PROVISION_SECRET'], :only => [:provision, :instance_user]
+
 
     def health
       if params[:error].present?
-        begin 
+        begin
           raise ZuoraConnect::Exceptions::Error.new('This is an error')
         rescue => ex
           case params[:error]
-          when 'Log'  
+          when 'Log'
             Rails.logger.error("Error in Health", ex)
           when 'Exception'
             raise
@@ -34,11 +31,13 @@ module ZuoraConnect
     def initialize_app
       begin
         authenticate_connect_app_request
-        @appinstance.new_session(:session => @appinstance.data_lookup(:session => session))
-        render json: {
-          message: "Success",
-          status: 200
-        }, status: 200
+        unless performed?
+          @appinstance.new_session(:session => @appinstance.data_lookup(:session => session))
+          render json: {
+            message: 'Success',
+            status: 200
+          }, status: 200
+        end
       rescue => ex
         Rails.logger.error("Failed to Initialize application", ex)
         if performed?
@@ -52,6 +51,74 @@ module ZuoraConnect
       end
     end
 
+    def provision
+      create_new_instance
+      unless performed?
+        render json: {
+          status: 200,
+          message: 'Success',
+          app_instance_id: @appinstance.id
+        }, status: 200
+      end
+    rescue StandardError => e
+      message = 'Failed to provision new instance'
+      if performed?
+        Rails.logger.error("#{message}: #{performed?}", e)
+      else
+        Rails.logger.error(message, e)
+        render json: {
+          status: 500,
+          message: message
+        }, status: 500
+      end
+    end
+
+    def instance_user
+      ZuoraConnect::AppInstance.read_master_db do
+        ZuoraConnect.logger.with_fields = {} if ZuoraConnect.logger.is_a?(Ougai::Logger)
+        Rails.logger.with_fields = {} if Rails.logger.is_a?(Ougai::Logger)
+
+        if defined?(ElasticAPM) && ElasticAPM.running? && ElasticAPM.respond_to?(:set_label)
+          ElasticAPM.set_label(:trace_id, request.uuid)
+        end
+
+        unless params[:id].present?
+          render json: {
+            status: 400,
+            message: 'No app instance id provided'
+          }, status: :bad_request
+          return
+        end
+
+        @appinstance = ZuoraConnect::AppInstance.find(params[:id]).new_session
+      end
+
+      zuora_client = @appinstance.send(ZuoraConnect::AppInstance::LOGIN_TENANT_DESTINATION).client
+      client_describe, = zuora_client.rest_call(
+        url: zuora_client.rest_endpoint('genesis/user/info').gsub('v1/', ''),
+        session_type: zuora_client.class == ZuoraAPI::Oauth ? :bearer : :basic
+      )
+
+      render json: {
+        status: 200,
+        message: 'Success',
+        user_id: client_describe['coreUserId'],
+        username: client_describe['username'],
+        email: client_describe['workEmail']
+      }, status: 200
+    rescue ActiveRecord::RecordNotFound
+      render json: {
+        status: 400,
+        message: 'No app instance found'
+      }, status: :bad_request
+    rescue StandardError => e
+      Rails.logger.error('Error occurred getting user details', e)
+      render json: {
+        status: 500,
+        message: 'Failed to get user details'
+      }, status: 500
+    end
+
     private
 
     def clear_connect_app_session

data/app/models/zuora_connect/app_instance_base.rb

@@ -11,8 +11,7 @@ module ZuoraConnect
     before_destroy :prune_data
 
     self.table_name = "zuora_connect_app_instances"
-    attr_accessor :options, :mode, :logins, :task_data, :last_refresh, :username, :password, :s3_client, :api_version, :drop_message, :new_session_message, :connect_user, :logitems
-    @@telegraf_host = nil
+    attr_accessor :options, :mode, :logins, :task_data, :last_refresh, :username, :password, :s3_client, :api_version, :drop_message, :new_session_message, :connect_user, :logitems, :user_timezone
     REFRESH_TIMEOUT = 2.minute                #Used to determine how long to wait on current refresh call before executing another
     INSTANCE_REFRESH_WINDOW = 1.hours         #Used to set how how long till app starts attempting to refresh cached task connect data
     INSTANCE_REDIS_CACHE_PERIOD = 24.hours    #Used to determine how long to cached task data will live for
@@ -21,6 +20,12 @@ module ZuoraConnect
     HOLDING_PATTERN_SLEEP = 5.seconds
     CONNECT_APPLICATION_ID = 0
     CONNECT_COMMUNICATION_SLEEP = Rails.env.test? ? 0.seconds : 5.seconds
+    CATALOG_LOOKUP_PAGE_SIZE = 10_000
+    CATALOG_LOOKUP_CACHE_TIME_KEY = 'CatalogCachedAt'
+    CATALOG_LOOKUP_TTL = 60.seconds
+    CATALOG_LOOKUP_CACHE_RESULT_KEY = 'CatalogCache'
+    TIMEZONE_LOG_RATE_LIMIT_KEY = 'TimezoneLoggedAt'
+    TIMEZONE_LOG_PERIOD = 4.hours
     IGNORED_LOCALS = ['fr', 'ja', 'es', 'zh', 'de']
     INTERNAL_HOSTS = []
     LOGIN_TENANT_DESTINATION = 'target_login'
@@ -29,7 +34,7 @@ module ZuoraConnect
       Aws::Errors::MissingCredentialsError,
       Aws::S3::Errors::AccessDenied,
       Aws::SES::Errors::AccessDenied,
-      Aws::KMS::Errors::AccessDeniedException 
+      Aws::KMS::Errors::AccessDeniedException
     ].freeze
     AWS_AUTH_ERRORS_MSG = "AWS Auth Errors".freeze
 
@@ -240,7 +245,9 @@ module ZuoraConnect
       rescue I18n::InvalidLocale => ex
         ZuoraConnect.logger.error(ex) if !IGNORED_LOCALS.include?(ex.locale.to_s.downcase)
       end
-      Time.zone = self.timezone
+
+      self.set_timezone
+
       if self.task_data.present?
         tenants = self.task_data.fetch('tenant_ids', [])
         organizations = self.task_data.fetch('organizations', [])
@@ -255,7 +262,7 @@ module ZuoraConnect
         end
 
         params = {
-          name: self.task_data.dig('name'), 
+          name: self.task_data.dig('name'),
           zuora_entity_ids: (self.task_data.dig(LOGIN_TENANT_DESTINATION,'entities') || []).map{|e| e['id']}.uniq,
           zuora_tenant_ids: tenants.map(&:to_s).uniq,
           organizations: organizations
@@ -264,7 +271,7 @@ module ZuoraConnect
           client = self.send(LOGIN_TENANT_DESTINATION).client
           if defined?(client.rest_domain)
             ZuoraConnect::RequestIdMiddleware.zuora_rest_domain = client.rest_domain
-            params.merge!({zuora_domain: client.rest_domain, environment: client.environment }) 
+            params.merge!({zuora_domain: client.rest_domain, environment: client.environment })
           end
         end
         params = params.reject{|k,v| !self.attributes.keys.member?(k.to_s) || self[k] == v}
@@ -272,12 +279,80 @@ module ZuoraConnect
       end
     end
 
-    def refresh(session: {}) 
+    def set_timezone(timezone: self.timezone, type: :default)
+      if timezone.blank?
+        timezone = self.timezone
+      end
+
+      if type == :default
+        Time.zone = timezone
+      elsif type == :user
+        begin
+          sql = <<-eos
+            SELECT zuora_users.zuora_identity_response 
+            FROM "#{self.id}".zuora_users 
+            ORDER BY zuora_users.updated_at DESC 
+            LIMIT 1;
+          eos
+          user = ActiveRecord::Base.connection.execute(sql).to_a.first
+
+          if user.present?
+            zuora_identity_response = JSON.parse(user.fetch('zuora_identity_response', '{}'))
+            self.user_timezone = zuora_identity_response.values.first&.dig('timeZone')
+          else
+            if (Redis.current.hget(TIMEZONE_LOG_RATE_LIMIT_KEY, self.id).to_i + TIMEZONE_LOG_PERIOD.to_i) <= Time.now.to_i
+              Rails.logger.error('Cannot find any user to set the timezone', app_instance_id: self.id)
+              Redis.current.hset(TIMEZONE_LOG_RATE_LIMIT_KEY, self.id, Time.now.to_i)
+            end
+          end
+        rescue => ex
+          Rails.logger.error('There is an error while getting timezone users', ex)
+        end
+
+        if self.user_timezone.present?
+          # connect instance which has a custom timezone
+          if !self.auto_deployed? && (
+            ActiveSupport::TimeZone[self.task_data.dig('user_settings', 'timezone') || '']&.utc_offset !=
+              ActiveSupport::TimeZone[self.user_timezone]&.utc_offset
+          )
+            if self.environment == 'Production' &&
+              (Redis.current.hget(TIMEZONE_LOG_RATE_LIMIT_KEY, self.id).to_i + TIMEZONE_LOG_PERIOD.to_i) <= Time.now.to_i
+              ZuoraConnect.logger.error(
+                "Instance and user timezones are different. User has '#{self.user_timezone}' and " \
+                "instance has '#{self.task_data.dig('user_settings', 'timezone')}'",
+                app_instance_id: self.id
+              )
+              Redis.current.hset(TIMEZONE_LOG_RATE_LIMIT_KEY, self.id, Time.now.to_i)
+            end
+            self.user_timezone = nil
+            Time.zone = timezone
+          else
+            begin
+              Time.zone = self.user_timezone
+            rescue ArgumentError
+              Rails.logger.error('Malformed user timezone', app_instance_id: self.id)
+              Time.zone = timezone
+            end
+          end
+        else
+          Time.zone = timezone
+        end
+      end
+    rescue => e
+      Rails.logger.error('Malformed timezone used', e, app_instance_id: self.id)
+      Time.zone = self.timezone
+    end
+
+    def auto_deployed?
+      self.id >= 25000000
+    end
+
+    def refresh(session: {})
       refresh_count ||= 0
       skip_connect ||= false
       begin
         #Check how app was deployed
-        if self.id < 25000000 && !skip_connect 
+        if self.id < 25000000 && !skip_connect
           self.check_oauth_state
           response = HTTParty.get(ZuoraConnect.configuration.url + "/api/#{self.api_version}/tools/tasks/#{self.id}.json",:body => {:access_token => self.access_token})
 
@@ -288,7 +363,7 @@ module ZuoraConnect
               raise ZuoraConnect::Exceptions::ConnectCommunicationError.new("JSON parse error", response.body, response.code)
             end
 
-            self.build_task(task_data: parsed_json, session: session)  
+            self.build_task(task_data: parsed_json, session: session)
             if self.kms_key.present? && self.kms_key.match(/^arn:aws:.*/)
               begin
                 self.zuora_logins = self.strip_cache_data(object: parsed_json.dup, keys: ['applications', 'tokens', 'user_settings'])
@@ -298,7 +373,7 @@ module ZuoraConnect
               rescue => ex
                 Rails.logger.error(AWS_AUTH_ERRORS_MSG, ex)
               end
-            end        
+            end
           else
             raise ZuoraConnect::Exceptions::ConnectCommunicationError.new("Error Communicating with Connect", response.body, response.code)
           end
@@ -338,6 +413,10 @@ module ZuoraConnect
       raise
     end
 
+    def aws_secrets
+      (Rails.application.secrets.aws || {}).transform_keys { |key| key.to_s }
+    end
+
     #### START KMS ENCRYPTION Methods ####
       def zuora_logins=(val)
         write_attribute(:zuora_logins, kms_encrypt(val.to_json))
@@ -350,7 +429,7 @@ module ZuoraConnect
 
       def kms_decrypt(value)
         kms_tries ||= 0
-        kms_client = Aws::KMS::Client.new({region: Rails.application.secrets.aws['AWS_REGION'], credentials: self.aws_auth_client}.delete_if { |k, v| v.blank? })
+        kms_client = Aws::KMS::Client.new({region: aws_secrets['AWS_REGION'], credentials: self.aws_auth_client}.delete_if { |k, v| v.blank? })
         resp = kms_client.decrypt({ciphertext_blob: [value].pack("H*") })
         return resp.plaintext
       rescue *AWS_AUTH_ERRORS => ex
@@ -365,7 +444,7 @@ module ZuoraConnect
 
       def kms_encrypt(value)
         kms_tries ||= 0
-        kms_client = Aws::KMS::Client.new({region: Rails.application.secrets.aws['AWS_REGION'], credentials: self.aws_auth_client}.delete_if {|k,v| v.blank? })
+        kms_client = Aws::KMS::Client.new({region: aws_secrets['AWS_REGION'], credentials: self.aws_auth_client}.delete_if {|k,v| v.blank? })
 
         resp = kms_client.encrypt({key_id: kms_key, plaintext: value})
         return resp.ciphertext_blob.unpack('H*').first
@@ -380,12 +459,12 @@ module ZuoraConnect
       end
 
       def kms_key
-        return ENV['AWS_KMS_ARN'] || Rails.application.secrets.dig(:aws,'AWS_KMS_ARN')
+        return ENV['AWS_KMS_ARN'] || aws_secrets['AWS_KMS_ARN']
       end
 
       def aws_auth_client
         if Rails.env.to_s == 'development'
-          return Aws::Credentials.new(Rails.application.secrets.aws['AWS_ACCESS_KEY_ID'], Rails.application.secrets.aws['AWS_SECRET_ACCESS_KEY'])
+          return Aws::Credentials.new(aws_secrets['AWS_ACCESS_KEY_ID'], aws_secrets['AWS_SECRET_ACCESS_KEY'])
         else
           return nil
         end
@@ -400,82 +479,6 @@ module ZuoraConnect
         end
         Thread.current[:appinstance] = self
       end
-
-      def self.write_to_telegraf(*args)
-        if ZuoraConnect.configuration.enable_metrics
-          @@telegraf_host = ZuoraConnect::Telegraf.new() if @@telegraf_host == nil
-          unicorn_stats = self.unicorn_listener_stats() if defined?(Unicorn) && Unicorn.respond_to?(:listener_names)
-          @@telegraf_host.write(direction: 'Raindrops', tags: {}, values: unicorn_stats)  unless unicorn_stats.blank?
-          return @@telegraf_host.write(*args)
-        end
-      end
-
-      def self.unicorn_listener_stats ()
-        stats_hash = {}
-        stats_hash["total_active"] = 0
-        stats_hash["total_queued"] = 0
-
-        begin 
-          tmp = Unicorn.listener_names
-          unix = tmp.grep(%r{\A/})
-          tcp = tmp.grep(/\A.+:\d+\z/)
-          tcp = nil if tcp.empty?
-          unix = nil if unix.empty?
-
-
-          Raindrops::Linux.tcp_listener_stats(tcp).each do |addr,stats|
-            stats_hash["active_#{addr}"] = stats.active
-            stats_hash["queued_#{addr}"] = stats.queued
-            stats_hash["total_active"] = stats.active + stats_hash["total_active"]
-            stats_hash["total_queued"] = stats.queued + stats_hash["total_queued"]
-          end if tcp
-
-          Raindrops::Linux.unix_listener_stats(unix).each do |addr,stats|
-            stats_hash["active_#{addr}"] = stats.active
-            stats_hash["queued_#{addr}"] = stats.queued
-            stats_hash["total_active"] = stats.active + stats_hash["total_active"]
-            stats_hash["total_queued"] = stats.queued + stats_hash["total_queued"]
-          end if unix
-        rescue IOError => ex
-        rescue => ex
-          ZuoraConnect.logger.error(ex)
-        end
-        return stats_hash
-      end
-
-      def self.get_metrics(type)
-        @data = {}
-
-        if type == "versions"
-          @data = {
-            app_name: ZuoraConnect::Telegraf.app_name,
-            url: "dummy",
-            Version_Gem: ZuoraConnect::VERSION,
-            Version_Zuora: ZuoraAPI::VERSION ,
-            Version_Ruby: RUBY_VERSION,
-            Version_Rails: Rails.version,
-            hold: 1
-          }
-        elsif type == "stats"
-          begin
-            Resque.redis.ping
-            @resque = Resque.info
-            @data = {
-              app_name: ZuoraConnect::Telegraf.app_name,
-              url: "dummy",
-              Resque:{
-                Jobs_Finished: @resque[:processed] ,
-                Jobs_Failed: @resque[:failed],
-                Jobs_Pending: @resque[:pending],
-                Workers_Active: @resque[:working],
-                Workers_Total: @resque[:workers]
-              }
-            }
-          rescue
-          end
-        end
-        return @data
-      end
     #### END Task Methods ####
 
     #### START Task Methods ####
@@ -518,7 +521,7 @@ module ZuoraConnect
         end
       rescue ZuoraConnect::Exceptions::MissMatch => ex
         raise
-      rescue ZuoraConnect::Exceptions::InvalidCredentialSet => ex 
+      rescue ZuoraConnect::Exceptions::InvalidCredentialSet => ex
         raise
       rescue => ex
         ZuoraConnect.logger.error("Build Task Error", ex)
@@ -574,10 +577,10 @@ module ZuoraConnect
         self.refresh if !defined?(self.target_login)
 
         response = HTTParty.get("#{ZuoraConnect.configuration.url}/api/#{self.api_version}/tenants/search?hostname=#{self.target_login.client.hostname}&node_id=#{self.zuora_entity_ids.first}")
-       
+
         if response.success?
           parsed_json =  JSON.parse(response.body)
-          
+
           #Set Org
           if self.id >= 25000000 && parsed_json['organization'].present?
             login_cache = self.zuora_logins
@@ -599,7 +602,7 @@ module ZuoraConnect
             end
           end
           self.save(:validate => false)
-         
+
           return parsed_json
         end
       rescue *(ZuoraAPI::Login::CONNECTION_EXCEPTIONS + ZuoraAPI::Login::CONNECTION_READ_EXCEPTIONS) => ex
@@ -653,7 +656,7 @@ module ZuoraConnect
       end
 
       def refresh_oauth
-        refresh_oauth_count ||= 0        
+        refresh_oauth_count ||= 0
         response = HTTParty.post("#{ZuoraConnect.configuration.url}/oauth/token", body: {
           :grant_type => "refresh_token",
           :redirect_uri => ZuoraConnect.configuration.oauth_client_redirect_uri,
@@ -955,13 +958,81 @@ module ZuoraConnect
       # object_id: The id or id's of the object/objects to be returned.
       # child_objects: Whether to include child objects of the object in question.
       # cache: Store individual "1" object lookup in redis for caching.
-      def catalog_lookup(entity_id: nil, object: :product, object_id: nil, child_objects: false, cache: false)
+      def catalog_lookup(entity_id: nil, object: :product, object_id: nil, child_objects: false, cache: false, source: 'DB')
         entity_reference = entity_id.blank? ? 'Default' : entity_id
 
         if object_id.present? && ![Array, String].include?(object_id.class)
           raise "Object Id can only be a string or an array of strings"
         end
 
+        if source == 'API'
+          catalog_container = {}
+
+          if (Redis.current.hget(CATALOG_LOOKUP_CACHE_TIME_KEY, self.id).to_i + CATALOG_LOOKUP_TTL.to_i) > Time.now.to_i
+            begin
+              catalog_container = JSON.parse(Redis.current.hget(CATALOG_LOOKUP_CACHE_RESULT_KEY, self.id))
+            rescue JSON::ParserError => ex
+              Rails.logger.warn('Failed to parse catalog cache', ex)
+            end
+          else
+            zuora_login = self.login_lookup(type: 'Zuora').first
+            login = zuora_login.client(entity_reference)
+
+            response = {
+              'nextPage' => login.rest_endpoint("catalog/products?pageSize=#{CATALOG_LOOKUP_PAGE_SIZE}")
+            }
+
+            while response['nextPage'].present?
+              url = login.rest_endpoint(response['nextPage'].split('/v1/').last)
+              output_json, response = login.rest_call(debug: false, url: url, timeout_retry: true)
+
+              case object
+              when :product
+                output_json.fetch('products', []).each do |product|
+                  rate_plans = {}
+                  product['productRatePlans'].each do |rate_plan|
+                    charges = {}
+                    rate_plan['productRatePlanCharges'].each do |charge|
+                      charges[charge['id']] = charge.merge(
+                        {
+                          'productId' => product['id'],
+                          'productName' => product['name'],
+                          'productRatePlanId' => rate_plan['id'],
+                          'productRatePlanName' => rate_plan['name'],
+                        }
+                      )
+                    end
+
+                    rate_plan['productRatePlanCharges'] = charges
+                    rate_plans[rate_plan['id']] = rate_plan.merge(
+                      {
+                        'productId' => product['id'],
+                        'productName' => product['name']
+                      }
+                    )
+                  end
+
+                  product['productRatePlans'] = rate_plans
+                  catalog_container[product['id']] = product
+                end
+              else
+                raise "Available objects include [:product]"
+              end
+            end
+
+            Redis.current.hset(CATALOG_LOOKUP_CACHE_RESULT_KEY, self.id, catalog_container.to_json)
+            Redis.current.hset(CATALOG_LOOKUP_CACHE_TIME_KEY, self.id, Time.now.to_i)
+          end
+
+          if object_id.nil?
+            catalog_container.transform_values! { |v| v.except('productRatePlans') }
+          elsif object_id.is_a?(String)
+            catalog_container = catalog_container[object_id]
+          end
+
+          return catalog_container
+        end
+
         if defined?(Redis.current) && object_id.present? && object_id.class == String && object_id.present?
           stub_catalog = cache ? decrypt_data(data: Redis.current.get("Catalog:#{self.id}:#{object_id}:Children:#{child_objects}")) : nil
           object_hierarchy = decrypt_data(data: Redis.current.get("Catalog:#{self.id}:#{object_id}:Hierarchy"))
@@ -1221,7 +1292,7 @@ module ZuoraConnect
 
     def self.without_sticking
        if self.connection.respond_to?(:without_sticking)
-        self.connection.without_sticking do 
+        self.connection.without_sticking do
           yield
         end
       else