wetransfer 0.4.4 → 0.9.0.beta1

data/lib/we_transfer_client/future_file.rb

@@ -0,0 +1,28 @@
+class FutureFile
+  attr_reader :name, :io
+
+  def initialize(name:, io:)
+    @name = name
+    @io = io
+  end
+
+  def to_request_params
+    {
+      name: @name,
+      size: @io.size,
+    }
+  end
+
+  def add_to_board(client:, remote_board:)
+    client.authorize_if_no_bearer_token!
+    response = client.faraday.post(
+      "/v2/boards/#{remote_board.id}/files",
+      # this needs to be a array with hashes => [{name, filesize}]
+      JSON.pretty_generate([to_request_params]),
+      client.auth_headers.merge('Content-Type' => 'application/json')
+    )
+    client.ensure_ok_status!(response)
+    file_item = JSON.parse(response.body, symbolize_names: true).first
+    remote_board.items << RemoteFile.new(file_item)
+  end
+end

data/lib/we_transfer_client/future_link.rb

@@ -0,0 +1,28 @@
+class FutureLink
+  attr_reader :url, :title
+
+  def initialize(url:, title: url)
+    @url = url
+    @title = title
+  end
+
+  def to_request_params
+    {
+      url: url,
+      title: title,
+    }
+  end
+
+  def add_to_board(client:, remote_board:)
+    client.authorize_if_no_bearer_token!
+    response = client.faraday.post(
+      "/v2/boards/#{remote_board.id}/links",
+      # this needs to be a array with hashes => [{name, filesize}]
+      JSON.pretty_generate([to_request_params]),
+      client.auth_headers.merge('Content-Type' => 'application/json')
+    )
+    client.ensure_ok_status!(response)
+    file_item = JSON.parse(response.body, symbolize_names: true).first
+    remote_board.items << RemoteLink.new(file_item)
+  end
+end

data/lib/we_transfer_client/future_transfer.rb

@@ -1,9 +1,15 @@
-class FutureTransfer < Ks.strict(:name, :description, :items)
-  def to_create_transfer_params
+class FutureTransfer
+  attr_accessor :message, :files
+
+  def initialize(message:, files: [])
+    @message = message
+    @files = files
+  end
+
+  def to_request_params
     {
-      name: name,
-      description: description,
-      items: items.map(&:to_item_request_params),
+      message: message,
+      files: files.map(&:to_request_params),
     }
   end
 end

data/lib/we_transfer_client/remote_board.rb

@@ -0,0 +1,47 @@
+class RemoteBoard
+  ItemTypeError = Class.new(NameError)
+
+  attr_reader :id, :items, :url, :state
+
+  CHUNK_SIZE = 6 * 1024 * 1024
+
+  def initialize(id:, state:, url:, name:, description: '', items: [])
+    @id = id
+    @state = state
+    @url = url
+    @name = name
+    @description = description
+    @items = to_instances(items: items)
+  end
+
+  def prepare_file_upload(client:, file:, part_number:)
+    url = file.request_board_upload_url(client: client, board_id: @id, part_number: part_number)
+    [url, CHUNK_SIZE]
+  end
+
+  def prepare_file_completion(client:, file:)
+    file.complete_board_file(client: client, board_id: @id)
+  end
+
+  def files
+    @items.select { |item| item.class == RemoteFile }
+  end
+
+  def links
+    @items.select { |item| item.class == RemoteLink }
+  end
+
+  private
+
+  def to_instances(items:)
+    items.map do |item|
+      begin
+        remote_class = "Remote#{item[:type].capitalize}"
+        Module.const_get(remote_class)
+          .new(item)
+      rescue NameError
+        raise ItemTypeError, "Cannot instantiate item with type '#{item[:type]}' and id '#{item[:id]}'"
+      end
+    end
+  end
+end

data/lib/we_transfer_client/remote_file.rb

@@ -0,0 +1,55 @@
+class RemoteFile
+  attr_reader :multipart, :name, :id, :url, :type
+
+  def initialize(id:, name:, size:, url: nil, type: 'file', multipart:)
+    @id = id
+    @name = name
+    @size = size
+    @url = url
+    @type = type
+    @size = size
+    multi = Struct.new(*multipart.keys)
+    @multipart = multi.new(*multipart.values)
+  end
+
+  def request_transfer_upload_url(client:, transfer_id:, part_number:)
+    response = client.faraday.get(
+      "/v2/transfers/#{transfer_id}/files/#{@id}/upload-url/#{part_number}",
+      {},
+      client.auth_headers.merge('Content-Type' => 'application/json')
+    )
+    client.ensure_ok_status!(response)
+    JSON.parse(response.body, symbolize_names: true).fetch(:url)
+  end
+
+  def request_board_upload_url(client:, board_id:, part_number:)
+    response = client.faraday.get(
+      "/v2/boards/#{board_id}/files/#{@id}/upload-url/#{part_number}/#{@multipart.id}",
+      {},
+      client.auth_headers.merge('Content-Type' => 'application/json')
+    )
+    client.ensure_ok_status!(response)
+    JSON.parse(response.body, symbolize_names: true).fetch(:url)
+  end
+
+  def complete_transfer_file(client:, transfer_id:)
+    body = {part_numbers: @multipart.part_numbers}
+    response = client.faraday.put(
+      "/v2/transfers/#{transfer_id}/files/#{@id}/upload-complete",
+      JSON.pretty_generate(body),
+      client.auth_headers.merge('Content-Type' => 'application/json')
+    )
+    client.ensure_ok_status!(response)
+    JSON.parse(response.body, symbolize_names: true)
+  end
+
+  def complete_board_file(client:, board_id:)
+    response = client.faraday.put(
+      "/v2/boards/#{board_id}/files/#{@id}/upload-complete",
+      '{}',
+      client.auth_headers.merge('Content-Type' => 'application/json')
+    )
+    client.ensure_ok_status!(response)
+    JSON.parse(response.body, symbolize_names: true)
+  end
+end

data/lib/we_transfer_client/remote_link.rb

@@ -0,0 +1,9 @@
+class RemoteLink
+  attr_reader :type
+  def initialize(id:, url:, type:, meta:)
+    @id = id
+    @url = url
+    @title = meta.fetch(:title)
+    @type = type
+  end
+end

data/lib/we_transfer_client/remote_transfer.rb

@@ -1,2 +1,25 @@
-class RemoteTransfer < Ks.strict(:id, :version_identifier, :state, :shortened_url, :name, :description, :size, :items)
+class RemoteTransfer
+  attr_reader :files, :url, :state, :id
+
+  def initialize(id:, state:, url:, message:, files: [])
+    @id = id
+    @state = state
+    @message = message
+    @url = url
+    @files = files_to_class(files)
+  end
+
+  def prepare_file_upload(client:, file:, part_number:)
+    url = file.request_transfer_upload_url(client: client, transfer_id: @id, part_number: part_number)
+    chunk_size = file.multipart.chunk_size
+    [url, chunk_size]
+  end
+
+  def prepare_file_completion(client:, file:)
+    file.complete_transfer_file(client: client, transfer_id: @id)
+  end
+
+  def files_to_class(files)
+    files.map { |x| RemoteFile.new(x) }
+  end
 end

data/lib/we_transfer_client/transfer_builder.rb

@@ -1,27 +1,20 @@
 class TransferBuilder
-  attr_reader :items
+  attr_reader :files
   class TransferIOError < StandardError; end
 
   def initialize
-    @items = []
+    @files = []
   end
 
   def add_file(name:, io:)
     ensure_io_compliant!(io)
-    @items << FutureFileItem.new(name: name, io: io)
-    true
+    @files << FutureFile.new(name: name, io: io)
   end
 
   def add_file_at(path:)
     add_file(name: File.basename(path), io: File.open(path, 'rb'))
   end
 
-  def add_web_url(url:, title: nil)
-    title ||= url
-    @items << FutureWebItem.new(url: url, title: title)
-    true
-  end
-
   def ensure_io_compliant!(io)
     io.seek(0)
     io.read(1) # Will cause things like Errno::EACCESS to happen early, before the upload begins

data/lib/we_transfer_client/transfers.rb

@@ -0,0 +1,73 @@
+module WeTransfer
+  class Client
+    module Transfers
+      def create_transfer_and_upload_files(message:, &block)
+        future_transfer = create_future_transfer(message: message, &block)
+        remote_transfer = create_remote_transfer(future_transfer)
+        remote_transfer.files.each do |file|
+          check_for_file_duplicates(future_transfer.files, file)
+          local_file = future_transfer.files.select { |x| x.name == file.name }.first
+          upload_file(object: remote_transfer, file: file, io: local_file.io)
+          complete_file!(object: remote_transfer, file: file)
+        end
+        complete_transfer(transfer: remote_transfer)
+      end
+
+      def get_transfer(transfer_id:)
+        request_transfer(transfer_id)
+      end
+
+      private
+
+      def create_transfer(message:, &block)
+        transfer = create_future_transfer(message: message, &block)
+        create_remote_transfer(transfer)
+      end
+
+      def complete_transfer(transfer:)
+        complete_transfer_call(transfer)
+      end
+
+      def create_future_transfer(message:, future_transfer_class: FutureTransfer, transfer_builder_class: TransferBuilder)
+        builder = transfer_builder_class.new
+        yield(builder)
+        future_transfer_class.new(message: message, files: builder.files)
+      rescue LocalJumpError
+        raise ArgumentError, 'No files were added to transfer'
+      end
+
+      def create_remote_transfer(xfer)
+        authorize_if_no_bearer_token!
+        response = faraday.post(
+          '/v2/transfers',
+          JSON.pretty_generate(xfer.to_request_params),
+          auth_headers.merge('Content-Type' => 'application/json')
+        )
+        ensure_ok_status!(response)
+        RemoteTransfer.new(JSON.parse(response.body, symbolize_names: true))
+      end
+
+      def complete_transfer_call(object)
+        authorize_if_no_bearer_token!
+        response = faraday.put(
+          "/v2/transfers/#{object.id}/finalize",
+          '',
+          auth_headers.merge('Content-Type' => 'application/json')
+        )
+        ensure_ok_status!(response)
+        RemoteTransfer.new(JSON.parse(response.body, symbolize_names: true))
+      end
+
+      def request_transfer(transfer_id)
+        authorize_if_no_bearer_token!
+        response = faraday.get(
+          "/v2/transfers/#{transfer_id}",
+          {},
+          auth_headers.merge('Content-Type' => 'application/json')
+        )
+        ensure_ok_status!(response)
+        RemoteTransfer.new(JSON.parse(response.body, symbolize_names: true))
+      end
+    end
+  end
+end

data/lib/we_transfer_client/version.rb

@@ -1,3 +1,3 @@
-class WeTransferClient
-  VERSION = '0.4.4'
+module WeTransfer
+  VERSION = '0.9.0.beta1'
 end

data/lib/we_transfer_client.rb

@@ -1,142 +1,108 @@
 require 'faraday'
 require 'logger'
-require 'ks'
-require 'securerandom'
 require 'json'
 
-class WeTransferClient
-  require_relative 'we_transfer_client/version'
-  require_relative 'we_transfer_client/future_file_item'
-  require_relative 'we_transfer_client/future_web_item'
-  require_relative 'we_transfer_client/future_transfer'
-  require_relative 'we_transfer_client/transfer_builder'
-  require_relative 'we_transfer_client/remote_transfer'
-  require_relative 'we_transfer_client/remote_item'
-
-  class Error < StandardError
-  end
-
-  NULL_LOGGER = Logger.new(nil)
-  MAGIC_PART_SIZE = 6 * 1024 * 1024
-
-  def initialize(api_key:, logger: NULL_LOGGER)
-    @api_url_base = 'https://dev.wetransfer.com'
-    @api_key = api_key.to_str
-    @bearer_token = nil
-    @logger = logger
-  end
-
-  def create_transfer(name:, description:)
-    builder = TransferBuilder.new
-    yield(builder)
-    future_transfer = FutureTransfer.new(name: name, description: description, items: builder.items)
-    create_and_upload(future_transfer)
-  end
-
-  def create_empty_transfer(name:, description:)
-    future_transfer = FutureTransfer.new(name: name, description: description, items: [])
-    create_and_upload(future_transfer)
-  end
-
-  def create_and_upload(xfer)
-    authorize_if_no_bearer_token!
-    response = faraday.post(
-      '/v1/transfers',
-      JSON.pretty_generate(xfer.to_create_transfer_params),
-      auth_headers.merge('Content-Type' => 'application/json')
-    )
-    ensure_ok_status!(response)
-    create_transfer_response = JSON.parse(response.body, symbolize_names: true)
-
-    remote_transfer = hash_to_struct(create_transfer_response, RemoteTransfer)
-    remote_transfer.items = remote_transfer.items.map do |remote_item_hash|
-      hash_to_struct(remote_item_hash, RemoteItem)
+require_relative 'we_transfer_client/version'
+require_relative 'we_transfer_client/transfer_builder'
+require_relative 'we_transfer_client/board_builder'
+require_relative 'we_transfer_client/future_file'
+require_relative 'we_transfer_client/future_link'
+require_relative 'we_transfer_client/future_transfer'
+require_relative 'we_transfer_client/future_board'
+require_relative 'we_transfer_client/remote_transfer'
+require_relative 'we_transfer_client/remote_board'
+require_relative 'we_transfer_client/remote_link'
+require_relative 'we_transfer_client/remote_file'
+require_relative 'we_transfer_client/transfers'
+require_relative 'we_transfer_client/boards'
+
+module WeTransfer
+  class Client
+    include WeTransfer::Client::Transfers
+    include WeTransfer::Client::Boards
+
+    class Error < StandardError
     end
 
-    item_id_map = Hash[xfer.items.map(&:local_identifier).zip(xfer.items)]
-
-    create_transfer_response.fetch(:items).each do |remote_item|
-      local_item = item_id_map.fetch(remote_item.fetch(:local_identifier))
-      next unless local_item.is_a?(FutureFileItem)
-      remote_item_id = remote_item.fetch(:id)
+    NULL_LOGGER = Logger.new(nil)
 
-      put_io_in_parts(
-        remote_item_id,
-        remote_item.fetch(:meta).fetch(:multipart_parts),
-        remote_item.fetch(:meta).fetch(:multipart_upload_id),
-        local_item.io
-      )
+    def initialize(api_key:, logger: NULL_LOGGER)
+      @api_url_base = 'https://dev.wetransfer.com'
+      @api_key = api_key.to_str
+      @bearer_token = nil
+      @logger = logger
+    end
 
-      complete_response = faraday.post(
-        "/v1/files/#{remote_item_id}/uploads/complete",
-        '{}',
-        auth_headers.merge('Content-Type' => 'application/json')
-      )
-      ensure_ok_status!(complete_response)
+    def upload_file(object:, file:, io:)
+      put_io_in_parts(object: object, file: file, io: io)
     end
-    remote_transfer
-  end
 
-  def hash_to_struct(hash, struct_class)
-    members = struct_class.members
-    struct_attrs = Hash[members.zip(hash.values_at(*members))]
-    struct_class.new(**struct_attrs)
-  end
+    def complete_file!(object:, file:)
+      object.prepare_file_completion(client: self, file: file)
+    end
 
-  def put_io_in_parts(item_id, n_parts, multipart_id, io)
-    chunk_size = MAGIC_PART_SIZE
-    (1..n_parts).each do |part_n_one_based|
-      response = faraday.get("/v1/files/#{item_id}/uploads/#{part_n_one_based}/#{multipart_id}", {}, auth_headers)
-      ensure_ok_status!(response)
-      response = JSON.parse(response.body, symbolize_names: true)
+    def check_for_file_duplicates(files, new_file)
+      if files.select { |file| file.name == new_file.name }.size != 1
+        raise ArgumentError, 'Duplicate file entry'
+      end
+    end
 
-      upload_url = response.fetch(:upload_url)
-      part_io = StringIO.new(io.read(chunk_size)) # needs a lens
-      part_io.rewind
-      response = faraday.put(upload_url, part_io, 'Content-Type' => 'binary/octet-stream', 'Content-Length' => part_io.size.to_s)
-      ensure_ok_status!(response)
+    def put_io_in_parts(object:, file:, io:)
+      (1..file.multipart.part_numbers).each do |part_n_one_based|
+        upload_url, chunk_size = object.prepare_file_upload(client: self, file: file, part_number: part_n_one_based)
+        part_io = StringIO.new(io.read(chunk_size))
+        part_io.rewind
+        response = faraday.put(
+          upload_url,
+          part_io,
+          'Content-Type' => 'binary/octet-stream',
+          'Content-Length' => part_io.size.to_s
+        )
+        ensure_ok_status!(response)
+      end
+      {success: true, message: 'File Uploaded'}
     end
-  end
 
-  def faraday
-    Faraday.new(@api_url_base) do |c|
-      c.response :logger, @logger
-      c.adapter Faraday.default_adapter
-      c.headers = { 'User-Agent' => "WetransferRubySdk/#{WeTransferClient::VERSION} Ruby #{RUBY_VERSION}"}
+    def faraday
+      Faraday.new(@api_url_base) do |c|
+        c.response :logger, @logger
+        c.adapter Faraday.default_adapter
+        c.headers = { 'User-Agent' => "WetransferRubySdk/#{WeTransfer::VERSION} Ruby #{RUBY_VERSION}"}
+      end
     end
-  end
 
-  def authorize_if_no_bearer_token!
-    return if @bearer_token
-    response = faraday.post('/v1/authorize', '{}', 'Content-Type' => 'application/json', 'X-API-Key' => @api_key)
-    ensure_ok_status!(response)
-    @bearer_token = JSON.parse(response.body, symbolize_names: true)[:token]
-    if @bearer_token.nil? || @bearer_token.empty?
-      raise Error, "The authorization call returned #{response.body} and no usable :token key could be found there"
+    def authorize_if_no_bearer_token!
+      return if @bearer_token
+      response = faraday.post('/v2/authorize', '{}', 'Content-Type' => 'application/json', 'X-API-Key' => @api_key)
+      ensure_ok_status!(response)
+      @bearer_token = JSON.parse(response.body, symbolize_names: true)[:token]
+      if @bearer_token.nil? || @bearer_token.empty?
+        raise Error, "The authorization call returned #{response.body} and no usable :token key could be found there"
+      end
     end
-  end
 
-  def auth_headers
-    raise 'No bearer token retrieved yet' unless @bearer_token
-    {
-      'X-API-Key' => @api_key,
-      'Authorization' => ('Bearer %s' % @bearer_token),
-    }
-  end
+    def auth_headers
+      raise 'No bearer token retrieved yet' unless @bearer_token
+      {
+        'X-API-Key' => @api_key,
+        'Authorization' => ('Bearer %s' % @bearer_token),
+      }
+    end
 
-  def ensure_ok_status!(response)
-    case response.status
-    when 200..299
-      nil
-    when 400..499
-      @logger.error { response.body }
-      raise Error, "Response had a #{response.status} code, the server will not accept this request even if retried"
-    when 500..504
-      @logger.error { response.body }
-      raise Error, "Response had a #{response.status} code, we could retry"
-    else
-      @logger.error { response.body }
-      raise Error, "Response had a #{response.status} code, no idea what to do with that"
+    def ensure_ok_status!(response)
+      case response.status
+      when 200..299
+        true
+      when 400..499
+        @logger.error response
+        raise Error, "Response had a #{response.status} code, the server will not accept this request even if retried"
+      when 500..504
+        @logger.error response
+        raise Error, "Response had a #{response.status} code, we could retry"
+      else
+        @logger.error response
+        raise Error, "Response had a #{response.status} code, no idea what to do with that"
+      end
     end
   end
 end