zuora_api_D 1.6.06

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0a408b85ca45825733c30c623994f5f736b7982b18258db77b723f9a53000344
+  data.tar.gz: 7f0f79b372f2383f8133324798b8bb442ceb6eedf36d22f64174415016fc941e
+SHA512:
+  metadata.gz: d07bec2378404b0cf4342fb8e52c9a3b9ad0d2f141ecca6bc4eca61c6c4e36e84c61fc5d430a95c19e3a7b8cf8672ba03b5812d602dc078bba9882db07b06bac
+  data.tar.gz: 6676504c96ce47af6ccaafe56241aaf1e05eed62dc9ba9274acf00f615dba1c78319b764b8eb6386bd4625fde8003c4f382c7f01715033e2d2d619164380b517

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.gitlab-ci.yml

@@ -0,0 +1,50 @@
+
+image: ruby:2.3.1
+stages:
+  - setup
+  - test
+  - deploy
+
+setup:
+  stage: setup
+  allow_failure: true
+  cache:
+    key: gems
+    paths:
+      - vendor/bundle
+  script:
+  - apt-get update -qy
+  - apt-get install -y nodejs
+  - bundle install
+
+rubocop-testing:
+  stage: test
+  allow_failure: true
+  script:
+  - gem install rubocop
+  - rubocop --lint
+
+security-testing:
+  stage: test
+  allow_failure: true
+  script:
+  - gem install brakeman
+  - brakeman
+
+rspec-testing:
+  stage: test
+  script:
+  - bundle install
+  - rspec
+
+rubygems-deploy:
+  stage: deploy
+  allow_failure: false
+  script:
+  - bundle install
+  - gem install rake
+  - version=$(rake install | grep -o 'pkg/zuora_api-.*gem')
+  - curl -u $USERNAME:$PASSWORD https://rubygems.org/api/v1/api_key.yaml > ~/.gem/credentials; chmod 0600 ~/.gem/credentials
+  - gem push $version
+  only:
+  - master

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.0
+before_install: gem install bundler -v 1.12.5

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in zuora.gemspec
+gemspec

data/README.md

@@ -0,0 +1,147 @@
+# Zuora Gem
+
+[![Gem Version](https://badge.fury.io/rb/zuora_api.svg)](https://badge.fury.io/rb/zuora_api) [![coverage report](https://gitlab.zuora.com/Connect/zuora-gem/badges/master/coverage.svg)](https://gitlab.zuora.com/Connect/zuora-gem/commits/master)
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'zuora_api'
+```
+Then execute `bundle install` in your terminal
+
+## Usage
+
+### Zuora Login Object
+In order to make API calls a Zuora Login object must be created
+
+```ruby
+zuora_client = ZuoraAPI::Login.new(username: "username", password: "password", url: "url")
+```
+
+|        Name         |    Type     |                                       Description                                        |                                                                       Example                                                                       |
+| ------------------- | ----------- | ---------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| username            | `Attribute` | Username to the Zuora environment                                                        | `zuora_client.username = "username"`                                                                                                                |
+| password            | `Attribute` | password to the Zuora environment                                                        | `zuora_client.password = "Password"`                                                                                                                |
+| url                 | `Attribute` | Endpoint to the Zuora tenant                                                             | `zuora_client.url = "www.zuora.com"`                                                                                                                |
+| wsdl_number         | `Attribute` | WSDL number of the zuora login                                                           | `wsdl = zuora_client.wsdl_number`                                                                                                                   |
+| status              | `Attribute` | Status of the login                                                                      | `zuora_client.status`                                                                                                                               |
+| current_session     | `Attribute` | Current session for the login                                                            | `zuora_client.current_session`                                                                                                                      |
+| environment         | `Attribute` | environment of the login                                                                 | `zuora_client.environment`                                                                                                                          |
+| errors              | `Attribute` | Any errors that the login has based on the login call                                    | `zuora_client.errors`                                                                                                                               |
+| current_error       | `Attribute` | Current error from the new_session call                                                  | `zuora_client.current_error`                                                                                                                        |
+| user_info           | `Attribute` | Information related to the login                                                         | `zuora_client.user_info`                                                                                                                            |
+| tenant_id           | `Attribute` | Tenant ID the login is associated to                                                     | `zuora_client.tenant_id`                                                                                                                            |
+| tenant_name         | `Attribute` | Tenant Name of tenant the login is associated to                                         | `zuora_client.tenant_name`                                                                                                                          |
+| entity_id           | `Attribute` | Current entity the login session is associated to                                        | `zuora_client.entity_id`                                                                                                                            |
+| rest_call           | `Method`    | Executes a REST call                                                                     | `zuora_client.rest_call()`                                                                                                                          |
+| soap_call           | `Method`    | Executes a SOAP call                                                                     | `output_xml, input_xml = zuora_client.soap_call() do `|xml, args|` xml['ns1'].query do xml['ns1'].queryString "select id, name from account" end end` |
+| query               | `Method`    | Executes a query call                                                                    | `zuora_client.query("select id, name from account")`                                                                                                |
+| getDataSourceExport | `Method`    | Pulls a data source export with the given query and returns the file location            | `zuora_client.getDataSourceExport("select id, name from account")`                                                                                  |
+| describe_call       | `Method`    | Performs the describe call against the Zuora tenant for all objects or a specific object | `response = zuora_client.describe_call("Account")`                                                                                                  |
+| createJournalRun    | `Method`    | Creates a Journal Run                                                                    | `zuora_client.createJournalRun(call)`                                                                                                               |
+| checkJRStatus       | `Method`    | Checks the status of a journal run                                                       | `zuora_client.checkJRStatus(journal_run_id)`                                                                                                        |
+| update_environment  | `Method`    | Sets the login's environment based on the url                                            | `zuora_client.update_environment`                                                                                                                   |
+| aqua_endpoint       | `Method`    | Returns the AQuA endpoint for the login based off the environment                        | `zuora_client.aqua_endpoint`                                                                                                                        |
+| rest_endpoint       | `Method`    | Returns the REST endpoint for the login based off the environment                        | `zuora_client.rest_endpoint`                                                                                                                          |
+| fileURL             | `Method`    | Returns the URL for files                                                                | `zuora_client.fileURL`                                                                                                                                |
+| dateFormat          | `Method`    | Returns the data format syntax based on the wsdl_number                                  | `zuora_client.dateFormat`                                                                                                                             |
+| new_session         | `Method`    | Create a new session                                                                     | `zuora_client.new_session`                                                                                                                          |
+| get_session         | `Method`    | Returns the current session                                                              | `zuora_client.get_session`|
+
+## Rest Call
+```ruby
+zuora_client.rest_call(method: :get, body: {}, url: zuora_client.rest_endpoint("catalog/products?pageSize=4"))
+```
+
+### Soap Call
+Returns both output and input XML
+
+```ruby
+zuora_client.soap_call(ns1: 'ns1', ns2: 'ns2', batch_size: nil, single_transaction: false)
+```
+
+Example Call
+
+```ruby
+output_xml, input_xml = zuora_client.soap_call() do |xml, args|
+ xml['ns1'].query do
+  xml['ns1'].queryString "select id, name from account"
+ end
+end
+```
+### Query
+```ruby
+zuora_client.query("select id from account")
+```
+### Data Export
+Returns the file location of the data source export after downloading from Zuora
+
+```ruby
+zuora_client.getDataSourceExport("select id from account")
+```
+
+|   Name    |                              Description                               | Default |                                    Example                                    |
+| --------- | ---------------------------------------------------------------------- | ------- | ----------------------------------------------------------------------------- |
+| query     | The query to execute                                                   | `N/A`   | `zuora_client.getDataSourceExport("select id from account")`                  |
+| zip       | Indicates if the data source export should be a zip                    | `true`  | `zuora_client.getDataSourceExport("select id from account", zip: false)`      |
+| extract   | Indicates if the data source export should be extracted if it is a zip | `true`  | `zuora_client.getDataSourceExport("select id from account", extract: false)`  |
+| encrypted | Indicates if the data source export should be encrypted                | `false` | `zuora_client.getDataSourceExport("select id from account", encrypted: true)` |
+
+### Describe Call
+This returns all available objects from the describe call as a hash. This response can be accessed by using response["Account"] to retrieve all related data about that object.
+
+```ruby
+response = zuora_client.describe_call("Account")
+```
+This returns all information and fields related to that object model as a hash.
+
+```ruby
+response = zuora_client.describe_call()
+```
+
+### Journal Run
+```ruby
+zuora_client.createJournalRun(call)
+```
+
+## Insights API
+
+In order to make API calls a Zuora Login object must be created by running:
+
+```ruby
+insightsapi = InsightsAPI::Login.new(api_token: "api token", url: "Nw1.api.insights.zuora.com/api/")
+```
+
+Note that the login will default to the insights production url.
+
+```ruby
+Date format: "YYYY-MM-DDT00:00:00Z"
+```
+
+### Uploading Data into Insights
+```ruby
+insightsapi.upload_into_insights(dataSourceName, recordType, batchDate, filePath)
+```
+dataSourceName: What system the data is coming from.
+recordType: The type of records ie: "EVENTS, ATTRIBUTES, and METRICS"
+batachDate: The date the data applies to.
+
+### Describing Insights Data
+```ruby
+insightsapi.describe(type: "ACCOUNT/USER", object: "ATTRIBUTES/EVENTS/SEGMENTS/METRICS")
+```
+Returns json payload describing attributes, events, metrics for each Account or User.
+
+### Downloading Data from Insights
+```ruby
+insightsapi.data_export_insights(objecttype, segmentuuid, startDate: nil, endDate: nil, tries: 30)
+```
+```ruby
+insightsapi.data_export_insights_file(objecttype, segmentuuid, startDate: nil, endDate: nil, tries: 30)
+```
+Both do the same thing except one returns a url(data_export_insights) to download the file yourself and the other returns an actual Ruby temporary file(data_export_insights_file).
+
+objectype: "ACCOUNT/USER"
+
+segmentuuid: A single or array of string or int of a segment uuid(s) that you get from the describe call. The csv holds a column with a bool that represents if that User or Account belongs to that segment.

data/Rakefile

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

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "zuora"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

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: tries)
+      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