strongmind_canvas_api_client 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ecdc4d036984a624014281bb150f72e812e935e6e903e0823c8928e41e5dfbd2
-  data.tar.gz: 969cb01b81fbecb2438135e98ade981a50270835726d6bbb9cfc19097b4bb3f7
+  metadata.gz: 7a031a2d0529c689391b4385842256b458a50d7d638be041da258672674ba1b0
+  data.tar.gz: b459407d9102314eb88f5968c696b9c6614797be12e5ff37047c3902a47c624f
 SHA512:
-  metadata.gz: f9ca5c76ba446eda623435e3b166bb7186ffaef31fd9aa4978ec2085d950c558edaadd6c2ee23771bd0fcb95cc8e8563b7c12920e51d8b5d35d37af80a08d891
-  data.tar.gz: 959dbae4ab4db96a551f14d433e4ee09fd844da383e75c77bc27dc63f9a44584e5cf84a1e8309f5cc7ef9069688b91bf63c8efdd7d1b3a1af269bc5804a3a360
+  metadata.gz: 977be903e5a67dadb4afe3f9a16e0ac71092932e2e1cd721d8c679028a720026e9224b8f593b00bdb95648e6cbb5b028fadeaf1c33109b2c31d516ce064751f7
+  data.tar.gz: 0bc6fc112e6df9100aec16cf9d88a431c5b5d01b8cc0ac5c05c3d7679033ead7c8e7b3deb2b6bcd280cd8941257d89168da061529f0589cda8e07ad4cc9eb36f

data/Gemfile.lock

@@ -1,21 +1,18 @@
 PATH
   remote: .
   specs:
-    strongmind_canvas_api_client (0.1.0)
-      canvas-api (~> 1.1, >= 1.1.1)
+    strongmind_canvas_api_client (0.1.1)
+      faraday
 
 GEM
   remote: https://rubygems.org/
   specs:
     ast (2.4.2)
-    canvas-api (1.1.1)
-      json
-      typhoeus
     diff-lcs (1.5.0)
-    ethon (0.15.0)
-      ffi (>= 1.15.0)
-    ffi (1.15.5)
-    json (2.6.2)
+    faraday (2.7.10)
+      faraday-net_http (>= 2.0, < 3.1)
+      ruby2_keywords (>= 0.0.4)
+    faraday-net_http (3.0.2)
     parallel (1.22.1)
     parser (3.1.2.0)
       ast (~> 2.4.1)
@@ -51,11 +48,10 @@ GEM
       rubocop (>= 1.7.0, < 2.0)
       rubocop-ast (>= 0.4.0)
     ruby-progressbar (1.11.0)
+    ruby2_keywords (0.0.5)
     standard (1.12.1)
       rubocop (= 1.29.1)
       rubocop-performance (= 1.13.3)
-    typhoeus (1.4.0)
-      ethon (>= 0.9.0)
     unicode-display_width (2.1.0)
 
 PLATFORMS

data/lib/canvas/canvas_api.rb

@@ -0,0 +1,342 @@
+require 'uri'
+require 'cgi'
+require 'net/http'
+require 'json'
+require 'faraday'
+
+module Canvas
+  class API
+    def initialize(args = {})
+      @host = args[:host] && args[:host].to_s
+      @token = args[:token] && args[:token].to_s
+      @client_id = args[:client_id] && args[:client_id].to_s
+      @secret = args[:secret] && args[:secret].to_s
+      @insecure = !!args[:insecure]
+      raise "host required" unless @host
+      raise "invalid host, protocol required" unless @host.match(/^http/)
+      raise "invalid host" unless @host.match(/^https?:\/\/[^\/]+$/)
+      raise "token or client_id required" if !@token && !@client_id
+      raise "secret required for client_id configuration" if @client_id && !@secret
+    end
+
+    attr_accessor :host
+    attr_accessor :token
+    attr_accessor :client_id
+
+    def masquerade_as(user_id)
+      @as_user_id = user_id && user_id.to_s
+    end
+
+    def stop_masquerading
+      @as_user_id = nil
+    end
+
+    def self.encode_id(prefix, id)
+      return nil unless prefix && id
+      "hex:#{prefix}:" + id.to_s.unpack("H*")[0]
+    end
+
+    def encode_id(prefix, id)
+      Canvas::API.encode_id(prefix, id)
+    end
+
+    def oauth_url(callback_url, scopes = "")
+      raise "client_id required for oauth flow" unless @client_id
+      raise "secret required for oauth flow" unless @secret
+      raise "callback_url required" unless callback_url
+      raise "invalid callback_url" unless (URI.parse(callback_url) rescue nil)
+      scopes ||= ""
+      scopes = scopes.length > 0 ? "&scopes=#{CGI.escape(scopes)}" : ""
+      "#{@host}/login/oauth2/auth?client_id=#{@client_id}&response_type=code&redirect_uri=#{CGI.escape(callback_url)}#{scopes}"
+    end
+
+    def login_url(callback_url)
+      oauth_url(callback_url, "/auth/userinfo")
+    end
+
+    def retrieve_access_token(code, callback_url)
+      raise "client_id required for oauth flow" unless @client_id
+      raise "secret required for oauth flow" unless @secret
+      raise "code required" unless code
+      raise "callback_url required" unless callback_url
+      raise "invalid callback_url" unless (URI.parse(callback_url) rescue nil)
+      @token = "ignore"
+      res = post("/login/oauth2/token", :client_id => @client_id, :redirect_uri => callback_url, :client_secret => @secret, :code => code)
+      if res['access_token']
+        @token = res['access_token']
+      end
+      res
+    end
+
+    def logout
+      !!delete("/login/oauth2/token")['logged_out']
+    end
+
+    def validate_call(endpoint)
+      raise "token required for api calls" unless @token
+      raise "missing host" unless @host
+      raise "missing endpoint" unless endpoint
+      raise "missing leading slash on endpoint" unless endpoint.match(/^\//)
+      raise "invalid endpoint" unless endpoint.match(/^\/api\/v\d+\//) unless @token == 'ignore'
+      raise "invalid endpoint" unless (URI.parse(endpoint) rescue nil)
+    end
+
+    def generate_uri(endpoint, params = nil)
+      validate_call(endpoint)
+      unless @token == "ignore"
+        endpoint += (endpoint.match(/\?/) ? "&" : "?") + "access_token=" + @token
+        endpoint += "&as_user_id=" + @as_user_id.to_s if @as_user_id
+      end
+      (params || {}).each do |key, value|
+        if value.is_a?(Array)
+          key = key + "[]" unless key.match(/\[\]/)
+          value.each do |val|
+            endpoint += (endpoint.match(/\?/) ? "&" : "?") + "#{CGI.escape(key.to_s)}=#{CGI.escape(val.to_s)}"
+          end
+        else
+          endpoint += (endpoint.match(/\?/) ? "&" : "?") + "#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}"
+        end
+      end
+      @uri = URI.parse(@host + endpoint)
+      @http = Net::HTTP.new(@uri.host, @uri.port)
+      @http.use_ssl = @uri.scheme == 'https'
+      @uri
+    end
+
+    def retrieve_response(response)
+      response_body = response.body
+      begin
+        response_status = response.status
+        if response_status.to_s.match(/3\d\d/)
+          raise ApiError.new("unexpected redirect to #{response.headers['Location']}")
+        end
+
+        json = JSON.parse(response_body) rescue { 'error' => 'invalid JSON' }
+
+        if !json.is_a?(Array)
+          if json['error']
+            raise ApiError.new(json['error'])
+          elsif json['errors']
+            raise ApiError.new(json['errors'])
+          elsif !response_status.to_s.match(/2\d\d/)
+            json['message'] ||= "unexpected error"
+            json['status'] ||= response_status.to_s
+            raise ApiError.new("#{json['status']} #{json['message']}")
+          end
+        else
+          json = ResultSet.new(self, json)
+          if response.headers['Link']
+            json.link = response.headers['Link']
+            json.next_endpoint = response.headers['Link'].split(/,/).detect { |rel| rel.match(/rel="next"/) }.split(/;/).first.strip[1..-2].sub(/https?:\/\/[^\/]+/, '') rescue nil
+          end
+        end
+
+        json
+      rescue Faraday::TimeoutError => e
+        raise ApiError.new("request timed out")
+      end
+    end
+
+    # Semi-hack so I can write better specs
+    def get_request(endpoint)
+      Faraday.get(endpoint) do |req|
+        req.headers['User-Agent'] = 'CanvasAPI Ruby'
+      end
+    end
+
+    def get(endpoint, params = nil)
+      uri = generate_uri(endpoint, params)
+      response = Faraday.get(uri.to_s)
+      retrieve_response(response)
+    end
+
+    def delete(endpoint, params = {})
+      uri = generate_uri(endpoint, params['query_parameters'] || params[:query_parameters])
+      response = Faraday.delete(uri.to_s)
+      retrieve_response(response)
+    end
+
+    def put(endpoint, params = {})
+      uri = generate_uri(endpoint, params['query_parameters'] || params[:query_parameters])
+      puts "params: #{params}"
+      puts "json params: #{params.to_json}"
+      puts "uri: #{uri}"
+      puts "new"
+      response = Faraday.put(uri.to_s) do |req|
+        req.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+        req.headers['Authorization'] = "Bearer #{@token}"
+        req.body = URI.encode_www_form(clean_params(params))
+      end
+      retrieve_response(response)
+    end
+
+    def post(endpoint, params = {})
+      uri = generate_uri(endpoint, params['query_parameters'] || params[:query_parameters])
+      response = Faraday.post(uri.to_s) do |req|
+        req.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+        req.headers['Authorization'] = "Bearer #{@token}"
+        req.body = URI.encode_www_form(clean_params(params))
+      end
+      retrieve_response(response)
+    end
+
+    def post_multi(endpoint, params = {})
+      uri = generate_uri(endpoint, params['query_parameters'] || params[:query_parameters])
+      response = Faraday.post(uri.to_s) do |req|
+        req.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+        req.headers['Authorization'] = "Bearer #{@token}"
+        req.body = URI.encode_www_form(clean_params(params))
+      end
+      retrieve_response(response)
+    end
+
+    def clean_params(params, prefix = nil)
+      pairs = PairArray.new
+
+      params.each do |key, value|
+        key = prefix.nil? ? key.to_s : "#{prefix}[#{key}]"
+
+        if value.is_a?(Hash)
+          pairs.concat(clean_params(value, key))
+        elsif value.is_a?(Array)
+          value.each_with_index do |v, index|
+            pairs << ["#{key}[#{index}]", v.to_s]
+          end
+        else
+          pairs << [key, value.to_s]
+        end
+      end
+
+      pairs
+    end
+
+    def upload_file_from_local(endpoint, file, opts = {})
+      raise "Missing File object" unless file.is_a?(File)
+      params = {
+        :size => file.size,
+        :name => opts[:name] || opts['name'] || File.basename(file.path),
+        :content_type => opts[:content_type] || opts['content_type'] || "application/octet-stream",
+        :on_duplicate => opts[:on_duplicate] || opts['on_duplicate']
+      }
+      if opts[:parent_folder_id] || opts['parent_folder_id']
+        params[:parent_folder_id] = opts[:parent_folder_id] || opts['parent_folder_id']
+      elsif opts[:parent_folder_path] || opts['parent_folder_path']
+        params[:parent_folder_path] = opts[:parent_folder_path] || opts['parent_folder_path']
+      end
+
+      res = post(endpoint, params)
+      if !res['upload_url']
+        raise ApiError.new("Unexpected error: #{res['message'] || 'no upload URL returned'}")
+      end
+      status_url = multipart_upload(res['upload_url'], res['upload_params'], params, file)
+      status_path = "/" + status_url.split(/\//, 4)[-1]
+      res = get(status_path)
+      res
+    end
+
+    def multipart_upload(url, upload_params, params, file)
+      response = Faraday.post(url) do |req|
+        req.headers['Authorization'] = "Bearer #{@token}"
+        req.headers['Content-Type'] = 'multipart/form-data'
+        req.body = {
+          'file' => Faraday::UploadIO.new(file.path, params[:content_type] || 'application/octet-stream'),
+          'size' => file.size.to_s,
+          'name' => params[:name] || File.basename(file.path),
+          'content_type' => params[:content_type] || 'application/octet-stream'
+        }.merge(upload_params)
+      end
+
+      if response.status == 201 && response.headers['Location']
+        response.headers['Location']
+      else
+        raise ApiError.new("Unexpected error: #{response.body}")
+      end
+    end
+
+    def upload_file_from_url(endpoint, opts)
+      asynch = opts.delete('asynch') || opts.delete(:asynch)
+      ['url', 'name', 'size'].each do |k|
+        raise "Missing value: #{k}" unless opts[k.to_s] || opts[k.to_sym]
+      end
+
+      res = post(endpoint, opts)
+      status_url = res['status_url']
+      if !status_url
+        raise ApiError.new("Unexpected error: #{res['message'] || 'no status URL returned'}")
+      end
+      status_path = "/" + status_url.split(/\//, 4)[-1]
+      if asynch
+        return status_path
+      else
+        attachment = nil
+        while !attachment
+          res = get(status_path)
+          if res['upload_status'] == 'errored'
+            raise ApiError.new(res['message'])
+          elsif !res['upload_status']
+            raise ApiError.new("Unexpected response")
+          end
+          status_path = res['status_path'] if res['status_path']
+          attachment = res['attachment']
+          sleep (defined?(SLEEP_TIME) ? SLEEP_TIME : 5) unless attachment
+        end
+        attachment
+      end
+    end
+  end
+
+  class ApiError < StandardError; end
+
+  class ResultSet < Array
+    def initialize(api, arr)
+      @api = api
+      super(arr)
+    end
+
+    attr_accessor :next_endpoint
+    attr_accessor :link
+
+    def more?
+      !!next_endpoint
+    end
+
+    def next_page!
+      ResultSet.new(@api, []) unless next_endpoint
+      more = @api.get(next_endpoint)
+      concat(more)
+      @next_endpoint = more.next_endpoint
+      @link = more.link
+      more
+    end
+  end
+
+  class PairArray < Array
+  end
+end
+
+# TODO: this is a hack that digs into the bowels of typhoeus
+module Ethon
+  class Easy
+    module Queryable
+      def recursively_generate_pairs(h, prefix, pairs)
+        case h
+        when Hash
+          h.each_pair do |k, v|
+            key = prefix.nil? ? k : "#{prefix}[#{k}]"
+            pairs_for(v, key, pairs)
+          end
+        when Canvas::PairArray
+          h.each do |k, v|
+            key = prefix.nil? ? k : "#{prefix}[#{k}]"
+            pairs_for(v, key, pairs)
+          end
+        when Array
+          h.each_with_index do |v, i|
+            key = "#{prefix}[#{i}]"
+            pairs_for(v, key, pairs)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/strongmind_canvas_api_client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module StrongmindCanvasApiClient
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/strongmind_canvas_api_client.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'canvas-api'
+require_relative "canvas/canvas_api"
 require_relative "strongmind_canvas_api_client/version"
 
 module StrongmindCanvasApiClient

metadata

@@ -1,35 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: strongmind_canvas_api_client
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Strongmind
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-08-15 00:00:00.000000000 Z
+date: 2023-08-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: canvas-api
+  name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.1
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.1
+        version: '0'
 description: Canvas API Client for Strongmind
 email:
 - steakholders@strongmind.com
@@ -47,6 +41,7 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- lib/canvas/canvas_api.rb
 - lib/strongmind_canvas_api_client.rb
 - lib/strongmind_canvas_api_client/version.rb
 - sig/strongmind_canvas_api_client.rbs