shotgrid_api_ruby 0.1.2

data/lib/shotgrid_api_ruby/entities/params.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module ShotgridApiRuby
+  class Entities
+    class Params < Hash
+      class TooComplexFiltersError < StandardError
+      end
+
+      def add_sort(sort)
+        return unless sort
+
+        self[:sort] =
+          if sort.is_a?(Hash)
+            sort.map do |field, direction|
+              "#{direction.to_s.start_with?('desc') ? '-' : ''}#{field}"
+            end.join(',')
+          else
+            [sort].flatten.join(',')
+          end
+      end
+
+      def add_page(page, page_size)
+        return unless page || page_size
+
+        page = page.to_i if page
+        page_size = page_size.to_i if page_size
+
+        page = 1 if page && page < 1
+        self[:page] = { size: page_size || 20, number: page || 1 }
+      end
+
+      def add_fields(fields)
+        self[:fields] =
+          fields && !fields.empty? ? [fields].flatten.join(',') : '*'
+      end
+
+      def add_options(return_only, include_archived_projects)
+        return if return_only.nil? && include_archived_projects.nil?
+
+        self[:options] = {
+          return_only: return_only ? 'retired' : 'active',
+          include_archived_projects: !!include_archived_projects,
+        }
+      end
+
+      def add_filter(filters, logical_operator = 'and')
+        return unless filters
+
+        self[:filter] =
+          if (self.class.filters_are_simple?(filters))
+            translate_simple_filters_to_sg(filters)
+          elsif filters.is_a? Hash
+            {
+              conditions:
+                filters[:conditions] || filters['conditions'] ||
+                  translate_complex_filters_to_sg(filters),
+              logical_operator:
+                filters[:logical_operator] || filters['logical_operator'] ||
+                  logical_operator,
+            }
+          else
+            { conditions: filters, logical_operator: logical_operator }
+          end
+      end
+
+      def add_grouping(grouping)
+        return unless grouping
+
+        if grouping.is_a? Array
+          self[:grouping] = grouping
+          return
+        end
+
+        self[:grouping] =
+          grouping
+            .each
+            .with_object([]) do |(key, options), result|
+              if options.is_a? Hash
+                result << {
+                  field: key.to_s,
+                  type:
+                    options[:type]&.to_s || options['type']&.to_s || 'exact',
+                  direction:
+                    options[:direction]&.to_s || options['direction']&.to_s ||
+                      'asc',
+                }
+              else
+                result << {
+                  field: key.to_s,
+                  type: 'exact',
+                  direction: options.to_s,
+                }
+              end
+            end
+      end
+
+      def add_summary_fields(summary_fields)
+        return unless summary_fields
+
+        if summary_fields.is_a? Array
+          self[:summary_fields] = summary_fields
+          return
+        end
+
+        if summary_fields.is_a? Hash
+          self[:summary_fields] =
+            summary_fields.map { |k, v| { field: k.to_s, type: v.to_s } }
+        end
+      end
+
+      def self.filters_are_simple?(filters)
+        return false if filters.is_a? Array
+
+        if filters.is_a?(Hash) &&
+             (filters[:conditions] || filters['conditions'])
+          return false
+        end
+
+        filters.values.all? do |filter_val|
+          (
+            filter_val.is_a?(Integer) || filter_val.is_a?(String) ||
+              filter_val.is_a?(Symbol)
+          ) ||
+            (
+              filter_val.is_a?(Array) && filter_val.all? do |val|
+                val.is_a?(String) || val.is_a?(Symbol) || val.is_a?(Integer)
+              end
+            )
+        end
+      end
+
+      private
+
+      def translate_simple_filters_to_sg(filters)
+        filters.map do |field, value|
+          [
+            field.to_s,
+            value.is_a?(Array) ? value.map(&:to_s).join(',') : value.to_s,
+          ]
+        end.to_h
+      end
+
+      def translate_complex_filters_to_sg(filters)
+        # We don't know how to translate anything but hashes
+        return filters if !filters.is_a?(Hash)
+
+        filters
+          .each
+          .with_object([]) do |item, result|
+            field, value = item
+            case value
+            when String, Symbol, Integer, Float
+              result << [field.to_s, 'is', value]
+            when Hash
+              value.each do |subfield, subvalue|
+                sanitized_subfield =
+                  if !subfield.to_s.include?('.')
+                    "#{field.capitalize}.#{subfield}"
+                  else
+                    subfield
+                  end
+                case subvalue
+                when String, Symbol, Integer, Float
+                  result << ["#{field}.#{sanitized_subfield}", 'is', subvalue]
+                when Array
+                  result << ["#{field}.#{sanitized_subfield}", 'in', subvalue]
+                else
+                  raise TooComplexFiltersError,
+                        'This case is too complex to auto-translate. Please use shotgrid query syntax.'
+                end
+              end
+            when Array
+              result << [field.to_s, 'in', value]
+            else
+              raise TooComplexFiltersError,
+                    'This case is too complex to auto-translate. Please use shotgrid query syntax.'
+            end
+          end
+      end
+    end
+  end
+end

data/lib/shotgrid_api_ruby/entities/schema.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ShotgridApiRuby
+  class Entities
+    class Schema
+      def initialize(connection, type, base_url_prefix)
+        @connection = connection.dup
+        @type = type
+        @connection.url_prefix = "#{base_url_prefix}/schema/#{type}"
+      end
+      attr_reader :type, :connection
+
+      def read
+        resp = @connection.get('')
+
+        if resp.status >= 300
+          raise "Error while read schema for #{type}: #{resp.body}"
+        end
+
+        resp_body = JSON.parse(resp.body)
+
+        OpenStruct.new(resp_body['data'].transform_values { |v| v['value'] })
+      end
+
+      def fields
+        resp = @connection.get('fields')
+        resp_body = JSON.parse(resp.body)
+
+        if resp.status >= 300
+          raise "Error while read schema fields for #{type}: #{resp.body}"
+        end
+
+        OpenStruct.new(
+          resp_body['data'].transform_values do |value|
+            OpenStruct.new(
+              value.transform_values { |attribute| attribute['value'] }.merge(
+                properties:
+                  OpenStruct.new(
+                    value['properties'].transform_values do |prop|
+                      prop['value']
+                    end,
+                  ),
+              ),
+            )
+          end,
+        )
+      end
+    end
+  end
+end

data/lib/shotgrid_api_ruby/entities/summarize.rb

@@ -0,0 +1,64 @@
+module ShotgridApiRuby
+  class Entities
+    class Summarize
+      Summary = Struct.new(:summaries, :groups)
+
+      def initialize(connection, type, base_url_prefix)
+        @connection = connection.dup
+        @type = type
+        @connection.url_prefix = "#{base_url_prefix}/entity/#{type}/_summarize"
+      end
+      attr_reader :type, :connection
+
+      def count(filter: nil, logical_operator: 'and')
+        result =
+          summarize(
+            filter: filter,
+            logical_operator: logical_operator,
+            summary_fields: [{ type: :record_count, field: 'id' }],
+          )
+        result.summaries&.[]('id') || 0
+      end
+
+      def summarize(
+        filter: nil,
+        grouping: nil,
+        summary_fields: nil,
+        logical_operator: 'and',
+        include_archived_projects: nil
+      )
+        params = Params.new
+
+        params.add_filter(filter, logical_operator)
+
+        params[:filters] = params[:filter] if params[:filter]
+        params.delete(:filter)
+
+        params.add_grouping(grouping)
+        params.add_summary_fields(summary_fields)
+        params.add_options(nil, include_archived_projects)
+
+        resp =
+          @connection.post('', params) do |req|
+            req.headers['Content-Type'] =
+              if params[:filters].is_a? Array
+                'application/vnd+shotgun.api3_array+json'
+              else
+                'application/vnd+shotgun.api3_hash+json'
+              end
+            req.body = params.to_h.to_json
+          end
+        resp_body = JSON.parse(resp.body)
+
+        if resp.status >= 300
+          raise "Error while getting summarize for #{type}: #{resp_body['errors']}"
+        end
+
+        Summary.new(
+          resp_body['data']['summaries'],
+          resp_body['data']&.[]('groups'),
+        )
+      end
+    end
+  end
+end

data/lib/shotgrid_api_ruby/entity.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module ShotgridApiRuby
+  # Represent each entity returned by Shotgrid
+  Entity =
+    Struct.new(:type, :attributes, :relationships, :id, :links) do
+      def method_missing(name, *args, &block)
+        if attributes.respond_to?(name)
+          define_singleton_method(name) { attributes.public_send(name) }
+          public_send(name)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(name, _private_methods = false)
+        attributes.respond_to?(name) || super
+      end
+    end
+end

data/lib/shotgrid_api_ruby/preferences.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ShotgridApiRuby
+  class Preferences
+    def initialize(connection)
+      @connection = connection.dup
+      @connection.url_prefix = "#{@connection.url_prefix}/preferences"
+    end
+
+    attr_reader :connection
+
+    def all
+      resp = @connection.get
+      resp_body = JSON.parse(resp.body)
+
+      if resp.status >= 300
+        raise "Error while getting server preferences: #{resp_body['errors']}"
+      end
+
+      data = resp_body['data']
+      OpenStruct.new(data)
+    end
+  end
+end

data/lib/shotgrid_api_ruby/server_info.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ShotgridApiRuby
+  class ServerInfo
+    def initialize(connection)
+      @connection = connection
+    end
+
+    attr_reader :connection
+
+    def get
+      resp = @connection.get
+      resp_body = JSON.parse(resp.body)
+
+      if resp.status >= 300
+        raise "Error while getting server infos: #{resp_body['errors']}"
+      end
+
+      data = resp_body['data']
+      OpenStruct.new(data)
+    end
+  end
+end

data/lib/shotgrid_api_ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ShotgridApiRuby
+  VERSION = '0.1.2'
+end

data/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "shotgrid_api_ruby",
+  "version": "1.0.0",
+  "main": "index.js",
+  "repository": "git@github.com:shotgunsoftware/shotgrid_api_ruby.git",
+  "author": "Denis <Zaratan> Pasin <zaratan@hey.com>",
+  "license": "MIT",
+  "devDependencies": {
+    "@prettier/plugin-ruby": "^1.3.0",
+    "prettier": "^2.2.1"
+  }
+}

data/shotgrid_api_ruby.gemspec

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'shotgrid_api_ruby/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'shotgrid_api_ruby'
+  spec.version = ShotgridApiRuby::VERSION
+  spec.authors = ['Denis <Zaratan> Pasin']
+  spec.email = ['denis.pasin@autodesk.com']
+
+  spec.summary = 'Gem to interact easily with Shotgrid REST api.'
+  spec.description =
+    "Gem to facilitate the interaction with Shotgrid's REST API."
+  spec.homepage = 'https://github.com/shotgunsoftware/shotgrid_api_ruby'
+  spec.license = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.5.0')
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] =
+    'https://github.com/shotgunsoftware/shotgrid_api_ruby'
+  spec.metadata['changelog_uri'] =
+    'https://github.com/shotgunsoftware/shotgrid_api_ruby/blob/main/CHANGELOG.md'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files =
+    Dir.chdir(File.expand_path(__dir__)) do
+      `git ls-files -z`.split("\x0").reject do |f|
+        f.match(%r{^(test|spec|features)/})
+      end
+    end
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'faraday', '~> 1'
+  spec.add_dependency 'zeitwerk', '~> 2.2'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'bundler-audit'
+  spec.add_development_dependency 'dotenv'
+  spec.add_development_dependency 'faker', '> 1.8'
+  spec.add_development_dependency 'guard-rspec', '> 4.7'
+  spec.add_development_dependency 'overcommit'
+  spec.add_development_dependency 'prettier'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rspec_in_context', '> 1'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-faker'
+  spec.add_development_dependency 'rubocop-performance'
+  spec.add_development_dependency 'simplecov', '> 0.16'
+  spec.add_development_dependency 'solargraph'
+  spec.add_development_dependency 'timecop'
+  spec.add_development_dependency 'vcr'
+  spec.add_development_dependency 'yard'
+end