zuora_connect 2.1.1 → 3.0.0k

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0342c5ac7396b4e8ba75aff8dbab5d579fa6d0ad04a421b7d1d809ab3abbd90a
-  data.tar.gz: 70f7277a93fec8e481f63e56f85e466b5e0b4d1307e2413e4f8da9497e980be2
+  metadata.gz: bad84d0fc35d26f517f83b2cc38e5d1569dafc4253c6c12a474f69aa9d9fee5e
+  data.tar.gz: 0ad1de0856425104abb6288662ca1481b097dfb3af696c40d1e8d5a1d018a0af
 SHA512:
-  metadata.gz: eb6497a343dde2b4a3edfe470c8e5a44eb37ff99b75ed434138c280e8ac25bf36806d58fbb477772182596917f1c37c0e237bd55e88f646e149743477fba2f15
-  data.tar.gz: f0b1f8b6f647f204ce8c4bfed7a8e77b49f3aada0faf6a0c31fc47675f5bfca67feb464692006bcb490977a577d1d5a3feab53886815f4c6472023e9ade6823b
+  metadata.gz: c00dcd65d70b84242e2c298f1d663d98259083c53e4232cf00c477b32fb32d480a49a39bf982a5682807ee0ae828905cd6dfeb1f548bf6e1a501dd4aca58c63e
+  data.tar.gz: 91fe7a9815f2340879cc0a30ef405b48960d44b54f1a020f193c5f029448b19ddb513944ce424fde25764cc0b5bf9a25ae25f3b70d124d715f69e4304ebf36d3

data/Rakefile

@@ -15,7 +15,7 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
 load 'rails/tasks/engine.rake'
 
 

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
 
@@ -147,7 +152,8 @@ module ZuoraConnect
       if ZuoraConnect.configuration.mode != "Production"
         mock_task_data = {
           "id" => ZuoraConnect.configuration.dev_mode_appinstance,
-          "mode" => ZuoraConnect.configuration.dev_mode_mode
+          "mode" => ZuoraConnect.configuration.dev_mode_mode,
+          "name" => "Developer Instance"
         }
 
         case ZuoraConnect.configuration.dev_mode_options.class
@@ -163,6 +169,7 @@ module ZuoraConnect
         end
 
         self.build_task(task_data: mock_task_data, session: session)
+        self.set_backup_creds if !self['zuora_logins'].present?
         self.last_refresh = Time.now.to_i
       else
         time_expire = (session["#{self.id}::last_refresh"] || Time.now).to_i - INSTANCE_REFRESH_WINDOW.ago.to_i
@@ -240,7 +247,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 +264,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 +273,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 +281,77 @@ 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.auto_deployed? && !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})
 
@@ -289,16 +363,8 @@ module ZuoraConnect
             end
 
             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'])
-                self.save(:validate => false)
-              rescue Aws::KMS::Errors::ValidationException, *AWS_AUTH_ERRORS => ex
-                Rails.logger.warn(AWS_AUTH_ERRORS_MSG, ex)
-              rescue => ex
-                Rails.logger.error(AWS_AUTH_ERRORS_MSG, ex)
-              end
-            end        
+            self.set_backup_creds
+            self.save(validate: false) if self.changed?    
           else
             raise ZuoraConnect::Exceptions::ConnectCommunicationError.new("Error Communicating with Connect", response.body, response.code)
           end
@@ -338,9 +404,21 @@ module ZuoraConnect
       raise
     end
 
+    def aws_secrets
+      (Rails.application.secrets.aws || {}).transform_keys { |key| key.to_s }
+    end
+
     #### START KMS ENCRYPTION Methods ####
+      def set_backup_creds
+        if self.kms_key.present? && self.kms_key.match(/^arn:aws:.*/) && self.task_data.present?
+          self.zuora_logins = self.strip_cache_data(object: self.task_data.dup, keys: ['applications', 'tokens', 'user_settings'])
+        end  
+      end 
+
       def zuora_logins=(val)
         write_attribute(:zuora_logins, kms_encrypt(val.to_json))
+      rescue Aws::KMS::Errors::ValidationException, Aws::KMS::Errors::NotFoundException, *AWS_AUTH_ERRORS => ex
+        Rails.logger.warn(AWS_AUTH_ERRORS_MSG, ex)
       end
 
       def zuora_logins
@@ -350,7 +428,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 +443,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 +458,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 +478,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 +520,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,12 +576,12 @@ 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?
+          if self.auto_deployed? && parsed_json['organization'].present?
             login_cache = self.zuora_logins
             login_cache.delete('organization')
             self.zuora_logins = login_cache.merge({'organizations' => [parsed_json['organization']]})
@@ -599,7 +601,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 +655,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 +957,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 +1291,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