zuora_api_oauth_alpha 2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 697c4df3ca9920d3096ca7346cc65d78c04add6999c39b34c365fa6963b2495d
+  data.tar.gz: 329058a2fe9d56f9b2c621bb7c5fe4fa7c846246f73f2c681a7a67c242fe6311
+SHA512:
+  metadata.gz: 543f66de8b66a9a349351cfe4611a807e61dfa9071ae3254300e32e60e2a2c03612a85760ecf90dad22e10ec225ccf15a55e12afcd7126ba19308b2d26bd80f2
+  data.tar.gz: 24e3dfce9db371969124cdc1ea410dbc29968ab9e56cffd29c002399fcc93eee626a3c1eda7a564f3f6f12a59c9d322fc39a9ae651d2b826622bb49167376427

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/insights_api/login.rb

@@ -0,0 +1,221 @@
+require "httparty"
+module InsightsAPI
+  class Login
+    attr_accessor :api_token, :url
+
+    def initialize(api_token: nil, url: nil, **keyword_args)
+      @api_token = api_token
+      @url = url
+      @status = "Active"
+    end
+
+    def insight_getstatus(uuid)
+      response = HTTParty.get(
+              "https://#{@url}/export/status/#{uuid}",
+              :basic_auth => { :username => @api_token })
+      if response.code == 200
+        parsed = JSON.parse(response.body)
+        return parsed
+      #error handing here
+      end
+    end
+
+    def data_export_insights_file(objecttype, segmentuuid, startDate, endDate, tries: 30)
+      status = data_export_insights(objecttype, segmentuuid, startDate, endDate, tries: 30)
+      if status['status']== "COMPLETE"
+        signedUrl = status['signedUrl']
+        return get_file(file_name: "insights-#{startDate}-#{endDate}.csv", url: signedUrl, headers: {}, count: 3, file_type: "zip")
+      else
+        return status
+      end
+    end
+
+    def data_export_insights(objecttype, segmentuuid, startDate, endDate, tries: 30)
+      status = insights_fetch_all(objecttype, segmentuuid, startDate, endDate)
+      if status['uuid'] == nil
+        return "Failed: #{status["response"]}"
+      else
+        fileid = status['uuid']
+      end
+      for retries in 1..tries
+        status = insight_getstatus(fileid)
+        if status['status']== "COMPLETE"
+          signedUrl = status['signedUrl']
+          return status
+        elsif status['status'] == "FAILED"
+          return status
+        else
+          sleep(60)
+          retries+=1
+        end
+        if retries > tries - 1
+          return "Timeout"
+        end
+      end
+      return signedUrl
+    end
+
+    def insights_fetch_all(objecttype, segmentuuid, startDate, endDate)
+      if segmentuuid.is_a? Array
+        segmentsForAPI = segmentuuid.join('","')
+      elsif segmentuuid.is_a? String
+        segmentsForAPI = segmentuuid
+      elsif segmentuuid.is_a? Integer
+        segmentsForAPI = segmentuuid.to_s
+      else
+        raise "Error fetching Insights data: Segmentuuid must be either an array of uuids or an single uuid in string or interger format."
+      end
+
+      response = HTTParty.post(
+              "https://#{@url}/export/type/#{objecttype}",
+              :basic_auth => { :username => @api_token },
+              :headers => {'Content-Type'=> "Application/json"},
+              :body =>
+              '
+              {
+                "endDate": "' + (dateFormat(date: endDate)).to_s + '",
+                "startDate":"' + (dateFormat(date: startDate)).to_s + '",
+                "segments": [
+                  "'+segmentsForAPI+'"
+                ]
+              }
+              ')
+      if response.code == 200
+        parsed = JSON.parse(response.body)
+        return parsed
+      else
+        return {"uuid"=> nil, "status"=>"Error", "signedUrl"=>"signedUrl", "response" => response.body}
+      end
+    end
+
+    def dateFormat(date: nil)
+      date ||= DateTime.now
+      if date.is_a? String
+        if date.include? "T"
+          return (date.to_datetime).to_s
+        else
+          return (date.to_date).to_s + "T#{DateTime.now.to_s(:time)}:00Z"
+        end
+      elsif date.instance_of?(DateTime)
+        return date.to_s
+      elsif date.instance_of?(Date)
+        return (date.to_date).to_s + "T#{DateTime.now.to_s(:time)}:00Z"
+      else
+        raise "Please pass in a in format of 'YYYY-MM-DD', 'YYYY-MM-DDT00:00:00+00:00' ruby Date, or ruby DateTime"
+      end
+    end
+
+    def upload_into_insights(dataSourceName, recordType, batchDate, filePath)
+      begin
+        temp_date = dateFormat(date: batchDate)
+        response = HTTParty.post(
+          "https://#{@url}/files/upload",
+          :basic_auth => { :username => @api_token }, :body => {
+          :dataSource => dataSourceName, :recordType => recordType,
+          :batchDate => temp_date})
+        parsed = JSON.parse(response.body)
+        signedUrl = parsed['signedUrl']
+        if !File.extname(filePath) == ".gz"
+          zipPath = gzip_file(filePath)
+        else
+          zipPath = filePath
+        end
+
+        gzippedFile = File.open(zipPath)
+        post = HTTParty.put(signedUrl,
+          :body => gzippedFile.read)
+        if post.code == 200
+          return {"status"=>"COMPLETE", "signedUrl"=>"#{signedUrl}", "response" => post.code, "batchDate" => "#{temp_date}"}
+        else
+          return {"status"=>"Error", "signedUrl"=>"#{signedUrl}", "response" => post.code, "message"=> "#{post.message}", "batchDate" => "#{temp_date}"}
+        end
+      rescue Exception => e
+          Rails.logger.debug "[ZuoraGem]: While uploading to insights Error: #{e}"
+        raise e
+      end
+    end
+
+    def describe(type: "ACCOUNT", object: "attributes")
+      url = "https://#{@url}/export/#{object}/#{type}"
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      begin
+        request = Net::HTTP::Get.new(uri.request_uri)
+        request.basic_auth(@api_token, "")
+        return http.request(request)
+      rescue Exception => e
+        Rails.logger.debug "[ZuoraGem]: While describing Zoura Insights objects: #{e}"
+        return "Failed"
+      end
+    end
+
+    def get_file(file_name: nil, url: nil,  basic: {:username => nil, :password => nil}, headers: {}, count: 3, file_type: "zip")
+      tries ||= 2
+      temp_file = nil
+      uri = URI(url)
+      Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
+        request = Net::HTTP::Get.new(uri)
+        headers.each do |k,v|
+          request["#{k}"] = v
+        end
+        request.basic_auth(basic[:username], basic[:password]) if (!basic[:username].blank? && !basic[:password].blank?)
+        http.request request do |response|
+          case response
+          when Net::HTTPNotFound
+            Rails.logger.fatal("[ZuoraGem]: 404 - Not Found")
+            raise response
+
+          when Net::HTTPUnauthorized
+            raise ZuoraAPI::Exceptions::ZuoraAPISessionError.new(zuora_client.current_error) if count <= 0
+            Rails.logger.fatal("[ZuoraGem]: Retry")
+            zuora_client.new_session
+            return get_file(:url => url, :count => count - 1, :headers => headers)
+
+          when Net::HTTPClientError
+            Rails.logger.debug("[ZuoraGem]: #{response}")
+            raise response
+
+          when Net::HTTPOK
+            Tempfile.open([file_name.rpartition('.').first, ".#{file_name.rpartition('.').last}"], "#{Rails.root}/tmp") do |tmp_file|
+              temp_file ||= tmp_file
+              tmp_file.binmode if (response.to_hash["content-type"].include?("application/zip") || response.to_hash["content-type"] == "application/zip")
+              response.read_body do |chunk|
+                tmp_file.write chunk.force_encoding("UTF-8")
+              end
+            end
+          end
+        end
+      end
+
+      rescue => ex
+        if !(tries -= 1).zero?
+         sleep 3
+         retry
+        else
+         raise ex
+        end
+      else
+        return temp_file
+    end
+
+    def gzip_file(filePath)
+      require "zip"
+      Zlib::GzipWriter.open(filePath + ".gz") do |gzip|
+         open(filePath, "rb") do |f|
+            f.each_chunk() {|chunk| gzip.write chunk }
+          end
+        gzip.close
+      end
+      return filePath+ ".gz"
+    end
+
+  end
+end
+
+class File
+  def each_chunk(chunk_size=2**16)
+      yield read(chunk_size) until eof?
+  end
+end

data/lib/zuora_api_oauth_alpha/exceptions.rb

@@ -0,0 +1,86 @@
+module ZuoraAPI
+  module Exceptions
+    class Error < StandardError; end
+    class AuthorizationNotPerformed < Error; end
+    class ZuoraAPISessionError < Error
+      attr_reader :code, :response
+      attr_writer :default_message
+
+      def initialize(message = nil)
+        @message = message
+        @default_message = "Error with Zuora Session."
+      end
+
+      def to_s
+        @message || @default_message
+      end
+    end
+
+    class ZuoraAPIError < Error
+      attr_reader :code, :response, :errors, :successes
+      attr_writer :default_message
+
+      def initialize(message = nil,response=nil, code =nil, errors = [], successes = [])
+        @code = code
+        @message = message
+        @response = response
+        @default_message = "Error communicating with Zuora."
+        @errors = errors
+        @successes = successes
+      end
+
+      def to_s
+        @message || @default_message
+      end
+    end
+
+    class ZuoraAPIRequestLimit < Error
+      attr_reader :code, :response
+      attr_writer :default_message
+
+      def initialize(message = nil,response=nil, code =nil)
+        @code = code
+        @message = message
+        @response = response
+        @default_message = "Your request limit has been exceeded for zuora."
+      end
+
+      def to_s
+        @message || @default_message
+      end
+    end
+
+    class ZuoraAPILockCompetition < Error
+      attr_reader :code, :response
+      attr_writer :default_message
+
+      def initialize(message = nil,response=nil, code =nil)
+        @code = code
+        @message = message
+        @response = response
+        @default_message = "Operation failed due to lock competition. Please retry"
+      end
+
+      def to_s
+        @message || @default_message
+      end
+    end
+
+
+    class ZuoraAPIAuthenticationTypeError < Error
+      attr_reader :code, :response
+      attr_writer :default_message
+
+      def initialize(message = nil,response=nil, code =nil)
+        @code = code
+        @message = message
+        @response = response
+        @default_message = "Authentication type is not supported by this Login"
+      end
+
+      def to_s
+        @message || @default_message
+      end
+    end
+  end
+end