shotgrid_api_ruby 0.1.2

data/Rakefile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'

data/bin/console

@@ -0,0 +1,48 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'shotgrid_api_ruby'
+
+require 'dotenv/load'
+
+if ENV['SHOTGUN_SITE_NAME'] && ENV['SCRIPT_NAME'] && ENV['SCRIPT_KEY']
+  $cl =
+    ShotgridApiRuby.new(
+      shotgun_site: ENV['SHOTGUN_SITE_NAME'],
+      auth: {
+        client_id: ENV['SCRIPT_NAME'],
+        client_secret: ENV['SCRIPT_KEY'],
+      },
+    )
+end
+if ENV['SITE_NAME'] && ENV['SCRIPT_NAME'] && ENV['SCRIPT_KEY']
+  $cl =
+    ShotgridApiRuby.new(
+      shotgrid_site: ENV['SITE_NAME'],
+      auth: {
+        client_id: ENV['SCRIPT_NAME'],
+        client_secret: ENV['SCRIPT_KEY'],
+      },
+    )
+end
+if ENV['SITE_URL'] && ENV['SCRIPT_NAME'] && ENV['SCRIPT_KEY']
+  $cl =
+    ShotgridApiRuby.new(
+      site_url: ENV['SITE_URL'],
+      auth: {
+        client_id: ENV['SCRIPT_NAME'],
+        client_secret: ENV['SCRIPT_KEY'],
+      },
+    )
+end
+
+# 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 'pry'
+Pry.start(__FILE__)

data/bin/prettirun

@@ -0,0 +1 @@
+yarn prettier -c './**/*.rb'

data/bin/ruborun

@@ -0,0 +1 @@
+bundle exec rubocop -P

data/bin/setup

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+overcommit --install

data/lib/shotgrid_api_ruby.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# zeitwerk will take care of auto loading files based on their name :)
+require 'zeitwerk'
+require 'active_support/core_ext/string/inflections'
+require 'ostruct'
+require 'faraday'
+require 'json'
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup # ready!
+
+module ShotgridApiRuby
+  def self.new(**args)
+    Client.new(**args)
+  end
+end
+
+loader.eager_load

data/lib/shotgrid_api_ruby/auth.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module ShotgridApiRuby
+  # Faraday middleware responsible for authentication with
+  # the shotgrid site
+  class Auth < Faraday::Middleware
+    # Validate auth parameters format
+    module Validator
+      # Validate auth parameters format
+      #
+      # @param []
+      def self.valid?(
+        client_id: nil,
+        client_secret: nil,
+        username: nil,
+        password: nil,
+        session_token: nil,
+        refresh_token: nil
+      )
+        (client_id && client_secret) || (password && username) ||
+          session_token || refresh_token
+      end
+    end
+
+    def initialize(app = nil, options = {})
+      raise 'missing auth' unless options[:auth]
+      raise 'missing site_url' unless options[:site_url]
+      unless Validator.valid?(**options[:auth]&.transform_keys(&:to_sym))
+        raise 'Auth not valid'
+      end
+
+      super(app)
+
+      @site_url = options[:site_url]
+      @client_id = options[:auth][:client_id]
+      @client_secret = options[:auth][:client_secret]
+      @username = options[:auth][:username]
+      @password = options[:auth][:password]
+      @session_token = options[:auth][:session_token]
+      @refresh_token = options[:auth][:refresh_token]
+    end
+
+    attr_reader :client_id,
+                :client_secret,
+                :site_url,
+                :username,
+                :password,
+                :session_token,
+                :refresh_token
+
+    def auth_type
+      @auth_type ||=
+        begin
+          if refresh_token
+            'refresh_token'
+          elsif client_id
+            'client_credentials'
+          elsif username
+            'password'
+          elsif session_token
+            'session_token'
+          end
+        end
+    end
+
+    def call(request_env)
+      request_env[:request_headers].merge!(std_headers)
+
+      @app.call(request_env)
+    end
+
+    private
+
+    def auth_params
+      @auth_params ||=
+        begin
+          case auth_type
+          when 'refresh_token'
+            "refresh_token=#{refresh_token}&grant_type=refresh_token"
+          when 'client_credentials'
+            "client_id=#{client_id}&client_secret=#{
+              client_secret
+            }&grant_type=client_credentials"
+          when 'password'
+            "username=#{username}&password=#{password}&grant_type=password"
+          when 'session_token'
+            "session_token=#{session_token}&grant_type=session_token"
+          else
+            raise 'Not a valid/implemented auth type'
+          end
+        end
+    end
+
+    def auth_url
+      @auth_url ||= "#{site_url}/auth/access_token?#{auth_params}"
+    end
+
+    def access_token
+      ((@access_token && Time.now < @token_expiry) || sign_in) && @access_token
+    end
+
+    def sign_in
+      resp =
+        Faraday.post(auth_url) do |req|
+          req.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+          req.headers['Accept'] = 'application/json'
+        end
+      resp_body = JSON.parse(resp.body)
+
+      raise "Can't login: #{resp_body['errors']}" if resp.status >= 300
+
+      @access_token = resp_body['access_token']
+      @token_expiry = Time.now + resp_body['expires_in']
+      @refresh_token = resp_body['refresh_token']
+    end
+
+    def std_headers
+      {
+        'Accept' => 'application/json',
+        'Authorization' => "Bearer #{access_token}",
+      }
+    end
+  end
+end

data/lib/shotgrid_api_ruby/client.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module ShotgridApiRuby
+  # Main class for connection.
+  #
+  # This should be only instanciated once to re-use tokens
+  class Client
+    # Faraday connection
+    attr_reader :connection
+
+    def initialize(auth:, site_url: nil, shotgun_site: nil, shotgrid_site: nil)
+      raise 'No site given' unless site_url || shotgun_site || shotgrid_site
+      raise 'auth param not valid' unless auth && Auth::Validator.valid?(**auth)
+
+      site_url ||=
+        if shotgun_site
+          "https://#{shotgun_site}.shotgunstudio.com/api/v1"
+        elsif shotgrid_site
+          "https://#{shotgrid_site}.shotgrid.autodesk.com/api/v1"
+        end
+
+      @connection =
+        Faraday.new(url: site_url) do |faraday|
+          faraday.use(ShotgridApiRuby::Auth, auth: auth, site_url: site_url)
+          faraday.adapter Faraday.default_adapter
+        end
+    end
+
+    # Access preferences APIs
+    def preferences
+      @preferences = Preferences.new(connection)
+    end
+
+    # Access server_info APIs
+    def server_info
+      @server_info || ServerInfo.new(connection)
+    end
+
+    # Access entities related APIs
+    def entities(type)
+      public_send(type)
+    end
+
+    def respond_to_missing?(_name, _include_private = false)
+      true
+    end
+
+    def method_missing(name, *args, &block)
+      if args.empty?
+        fname = formated_name(name)
+        self
+          .class
+          .define_method(fname) do
+            if entities_client = instance_variable_get("@#{fname}")
+              entities_client
+            else
+              entities_client = entities_aux(fname)
+              instance_variable_set("@#{fname}", entities_client)
+            end
+          end
+        self.class.instance_eval { alias_method name, fname }
+        send(fname)
+      else
+        super
+      end
+    end
+
+    private
+
+    def formated_name(name)
+      name.to_s.camelize.singularize
+    end
+
+    def entities_aux(type)
+      type = formated_name(type)
+      @entity_caller = Entities.new(connection, type)
+    end
+  end
+end

data/lib/shotgrid_api_ruby/entities.rb

@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+module ShotgridApiRuby
+  class Entities
+    def initialize(connection, type)
+      @connection = connection.dup
+      @type = type
+      @base_url_prefix = @connection.url_prefix
+      @connection.url_prefix = "#{@connection.url_prefix}/entity/#{type}"
+    end
+
+    attr_reader :connection, :type
+
+    def first(
+      fields: nil,
+      sort: nil,
+      filter: nil,
+      retired: nil,
+      include_archived_projects: nil,
+      logical_operator: 'and'
+    )
+      all(
+        fields: fields,
+        sort: sort,
+        filter: filter,
+        retired: retired,
+        logical_operator: logical_operator,
+        include_archived_projects: include_archived_projects,
+        page_size: 1,
+      ).first
+    end
+
+    def find(id, fields: nil, retired: nil, include_archived_projects: nil)
+      params = Params.new
+
+      params.add_fields(fields)
+      params.add_options(retired, include_archived_projects)
+
+      resp = @connection.get(id.to_s, params)
+      resp_body = JSON.parse(resp.body)
+
+      if resp.status >= 300
+        raise "Error while getting #{type}: #{resp_body['errors']}"
+      end
+
+      entity = resp_body['data']
+      Entity.new(
+        entity['type'],
+        OpenStruct.new(entity['attributes']),
+        entity['relationships'],
+        entity['id'],
+        entity['links'],
+      )
+    end
+
+    def create(attributes)
+      resp =
+        @connection.post('', attributes.to_json) do |req|
+          req.headers['Content-Type'] = 'application/json'
+        end
+
+      resp_body = JSON.parse(resp.body)
+
+      if resp.status >= 300
+        raise "Error while creating #{type} with #{attributes}: #{
+                resp_body['errors']
+              }"
+      end
+
+      entity = resp_body['data']
+      Entity.new(
+        entity['type'],
+        OpenStruct.new(entity['attributes']),
+        entity['relationships'],
+        entity['id'],
+        entity['links'],
+      )
+    end
+
+    def update(id, changes)
+      return find(id) if changes.empty?
+
+      resp =
+        @connection.put(id.to_s, changes.to_json) do |req|
+          req.headers['Content-Type'] = 'application/json'
+        end
+
+      resp_body = JSON.parse(resp.body)
+
+      if resp.status >= 300
+        raise "Error while updating #{type}##{id} with #{changes}: #{
+                resp_body['errors']
+              }"
+      end
+
+      entity = resp_body['data']
+      Entity.new(
+        entity['type'],
+        OpenStruct.new(entity['attributes']),
+        entity['relationships'],
+        entity['id'],
+        entity['links'],
+      )
+    end
+
+    def delete(id)
+      resp =
+        @connection.delete(id.to_s) do |req|
+          req.headers['Content-Type'] = 'application/json'
+        end
+
+      if resp.status >= 300
+        resp_body = JSON.parse(resp.body)
+        raise "Error while deleting #{type}##{id}: #{resp_body['errors']}"
+      end
+
+      true
+    end
+
+    def revive(id)
+      resp = @connection.post("#{id}?revive=true")
+
+      if resp.status >= 300
+        resp_body = JSON.parse(resp.body)
+        raise "Error while reviving #{type}##{id}: #{resp_body['errors']}"
+      end
+
+      true
+    end
+
+    def all(
+      fields: nil,
+      logical_operator: 'and',
+      sort: nil,
+      filter: nil,
+      page: nil,
+      page_size: nil,
+      retired: nil,
+      include_archived_projects: nil
+    )
+      if filter && !Params.filters_are_simple?(filter)
+        return(
+          search(
+            fields: fields,
+            logical_operator: logical_operator,
+            sort: sort,
+            filter: filter,
+            page: page,
+            page_size: page_size,
+            retired: retired,
+            include_archived_projects: include_archived_projects,
+          )
+        )
+      end
+
+      params = Params.new
+
+      params.add_fields(fields)
+      params.add_sort(sort)
+      params.add_filter(filter)
+      params.add_page(page, page_size)
+      params.add_options(retired, include_archived_projects)
+
+      resp = @connection.get('', params)
+      resp_body = JSON.parse(resp.body)
+
+      if resp.status >= 300
+        raise "Error while getting #{type}: #{resp_body['errors']}"
+      end
+
+      resp_body['data'].map do |entity|
+        Entity.new(
+          entity['type'],
+          OpenStruct.new(entity['attributes']),
+          entity['relationships'],
+          entity['id'],
+          entity['links'],
+        )
+      end
+    end
+
+    def search(
+      fields: nil,
+      logical_operator: 'and',
+      sort: nil,
+      filter: nil,
+      page: nil,
+      page_size: nil,
+      retired: nil,
+      include_archived_projects: nil
+    )
+      if filter.nil? || Params.filters_are_simple?(filter)
+        return(
+          all(
+            fields: fields,
+            logical_operator: logical_operator,
+            sort: sort,
+            filter: filter,
+            page: page,
+            page_size: page_size,
+            retired: retired,
+            include_archived_projects: include_archived_projects,
+          )
+        )
+      end
+      params = Params.new
+
+      params.add_fields(fields)
+      params.add_sort(sort)
+      params.add_page(page, page_size)
+      params.add_options(retired, include_archived_projects)
+      params.add_filter(filter, logical_operator)
+
+      # In search: The name is filters and not filter
+      params[:filters] = params[:filter] if params[:filter]
+      params.delete(:filter)
+
+      resp =
+        @connection.post('_search', 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 #{type}: #{resp_body['errors']}"
+      end
+
+      resp_body['data'].map do |entity|
+        Entity.new(
+          entity['type'],
+          OpenStruct.new(entity['attributes']),
+          entity['relationships'],
+          entity['id'],
+          entity['links'],
+        )
+      end
+    end
+
+    def schema_client
+      @schema_client ||= Schema.new(connection, type, @base_url_prefix)
+    end
+
+    def schema
+      schema_client.read
+    end
+
+    def fields
+      schema_client.fields
+    end
+
+    def summary_client
+      @summary_client ||= Summarize.new(connection, type, @base_url_prefix)
+    end
+
+    def count(filter: nil, logical_operator: 'and')
+      summary_client.count(filter: filter, logical_operator: logical_operator)
+    end
+
+    def summarize(
+      filter: nil,
+      grouping: nil,
+      summary_fields: nil,
+      logical_operator: 'and',
+      include_archived_projects: nil
+    )
+      summary_client.summarize(
+        filter: filter,
+        grouping: grouping,
+        summary_fields: summary_fields,
+        logical_operator: logical_operator,
+        include_archived_projects: include_archived_projects,
+      )
+    end
+  end
+end