wetransfer 0.1.0

data/lib/wetransfer.rb

@@ -0,0 +1,16 @@
+require 'faraday'
+require 'json'
+require 'dotenv'
+Dotenv.load
+
+require 'wetransfer/version'
+require 'wetransfer/client'
+require 'wetransfer/transfer'
+require 'wetransfer/transfer_builder'
+require 'wetransfer/item'
+require 'wetransfer/item_builder'
+require 'wetransfer/connection'
+
+module WeTransfer
+
+end

data/lib/wetransfer/client.rb

@@ -0,0 +1,126 @@
+module WeTransfer
+  class Client
+    attr_accessor :api_key
+    attr_reader :api_connection
+    CHUNK_SIZE = 6_291_456
+
+    # Initializes a new Client object
+    def initialize(api_key:)
+      @api_path = ENV.fetch('WT_API_CONNECTION_PATH') { '' }
+      @api_key = api_key
+      @api_bearer_token ||= request_jwt
+      @api_connection ||= WeTransfer::Connection.new(client: self, api_bearer_token: @api_bearer_token)
+    end
+
+    def request_jwt
+      # Create a connection request without a bearer token for authorization
+      # since authorization is what you need to do to retrieve the token.
+      auth_connection = WeTransfer::Connection.new(client: self)
+      auth_connection.authorization_request
+    end
+
+    # If you pass in items to the transfer it'll create the transfer with them,
+    # otherwise it creates a "blank" transfer object. You can also leave off the
+    # name and description, and it will be auto-generated.
+    def create_transfer(name: nil, description: nil, items: [])
+      raise ArgumentError, 'The items field must be an array' unless items.is_a?(Array)
+      @transfer = build_transfer_object(name, description).transfer
+      items.any? ? create_transfer_with_items(items: items) : create_initial_transfer
+      @transfer
+    end
+
+    # Once you've created a "blank" transfer you can use this to add items to it.
+    # Items must have the structure defined in the README, otherwise information will be auto-generated for them.
+    def add_items(transfer:, items:)
+      @transfer ||= transfer
+      create_transfer_items(items: items)
+      send_items_to_transfer
+      upload_and_complete_items
+      @transfer
+    end
+
+    def create_transfer_with_items(items: [])
+      raise ArgumentError, 'Items array cannot be empty' if items.empty?
+      create_transfer_items(items: items)
+      create_initial_transfer
+      upload_and_complete_items
+    end
+
+    private
+
+    def build_transfer_object(name, description)
+      transfer_builder = TransferBuilder.new
+      transfer_builder.name_description(name: name, description: description)
+      transfer_builder
+    end
+
+    def create_transfer_items(items:)
+      items.each do |item|
+        item_builder = ItemBuilder.new
+        item_builder.path(path: item)
+        item_builder.content_identifier
+        item_builder.local_identifier
+        item_builder.name
+        item_builder.size
+        @transfer.items.push(item_builder.item)
+      end
+    end
+
+    def create_initial_transfer
+      response = @api_connection.post_request(path: '/transfers', body: @transfer.transfer_params)
+      TransferBuilder.id(transfer: @transfer, id: response['id'])
+      TransferBuilder.shortened_url(transfer: @transfer, url: response['shortened_url'])
+      update_item_objects(response_items: response['items']) if response['items'].any?
+    end
+
+    def send_items_to_transfer
+      response = @api_connection.post_request(path: "/transfers/#{@transfer.id}/items", body: {items: @transfer.items_params})
+      update_item_objects(response_items: response)
+    end
+
+    def update_item_objects(response_items:)
+      response_items.each do |item|
+        item_object = @transfer.items.select { |t| t.name == item['name'] }.first
+        item_builder = ItemBuilder.new(item: item_object)
+        item_builder.id(item: item_object, id: item['id'])
+        item_builder.upload_url(item: item_object, url: item['upload_url'])
+        item_builder.multipart_parts(item: item_object, part_count: item['meta']['multipart_parts'])
+        item_builder.multipart_id(item: item_object, multi_id: item['meta']['multipart_upload_id'])
+        item_builder.upload_id(item: item_object, upload_id: item['upload_id'])
+        add_item_upload_url(item: item_builder.item) if item_builder.item.multipart_parts > 1
+      end
+    end
+
+    def add_item_upload_url(item:)
+      upload_urls = []
+      item.multipart_parts.times do |part|
+        part += 1
+        response = @api_connection.get_request(path: "/files/#{item.id}/uploads/#{part}/#{item.multipart_id}")
+        upload_urls << response['upload_url']
+      end
+      item.upload_url = upload_urls
+    end
+
+    def upload_and_complete_items
+      upload_files
+      complete_transfer
+    end
+
+    def upload_files
+      @transfer.items.each do |item|
+        file_object = File.open(item.path)
+        item.upload_url.each do |url|
+          chunk = file_object.read(CHUNK_SIZE)
+          @api_connection.upload(file: chunk, url: url)
+        end
+        file_object.close
+      end
+    end
+
+    def complete_transfer
+      @transfer.items.each do |item|
+        @api_connection.post_request(path: "/files/#{item.id}/uploads/complete")
+      end
+    end
+  end
+end

data/lib/wetransfer/connection.rb

@@ -0,0 +1,77 @@
+module WeTransfer
+  class Connection
+    class ApiRequestError < StandardError; end
+
+    attr_reader :api_connection, :api_bearer_token, :api_key, :api_path
+
+    def initialize(client:, api_bearer_token: '')
+      @api_url = ENV.fetch('WT_API_URL') { 'https://dev.wetransfer.com' }
+      @api_key = client.api_key
+      @api_connection ||= create_api_connection_object!
+      @api_bearer_token = api_bearer_token
+      @api_path = ENV.fetch('WT_API_CONNECTION_PATH') { '' }
+    end
+
+    def authorization_request
+      response = @api_connection.post do |req|
+        req.url("#{@api_path}/authorize")
+        request_header_params(req: req)
+      end
+      response_validation!(response: response)
+      response['token']
+    end
+
+    def post_request(path:, body: nil)
+      response = @api_connection.post do |req|
+        req.url(@api_path + path)
+        request_header_params(req: req)
+        req.body = body.to_json unless body.nil?
+      end
+      response_validation!(response: response)
+      JSON.parse(response.body)
+    end
+
+    def get_request(path:)
+      response = @api_connection.get do |req|
+        req.url(@api_path + path)
+        request_header_params(req: req)
+      end
+      response_validation!(response: response)
+      JSON.parse(response.body)
+    end
+
+    def upload(file:, url:)
+      conn = Faraday.new(url: url) do |faraday|
+        faraday.request :multipart
+        faraday.adapter :net_http
+      end
+      resp = conn.put do |req|
+        req.headers['Content-Length'] = file.size.to_s
+        req.body = file
+      end
+      response_validation!(response: resp)
+    end
+
+    private
+
+    def request_header_params(req:)
+      req.headers['X-API-Key'] = @api_key
+      req.headers['Authorization'] = 'Bearer ' + @api_bearer_token unless @api_bearer_token.nil?
+      req.headers['Content-Type'] = 'application/json'
+    end
+
+    # If you need extra logging for your requests, switch it on by setting WT_API_LOGGING_ON in your .env file.
+    def create_api_connection_object!
+      conn = Faraday.new(url: @api_url) do |faraday|
+        faraday.response :logger if ENV.fetch('WT_API_LOGGING_ON') { nil } # log requests to STDOUT if ENVVAR is present
+        faraday.adapter  Faraday.default_adapter  # make requests with Net::HTTP
+      end
+      conn
+    end
+
+    def response_validation!(response:)
+      raise ApiRequestError, response.reason_phrase if response.status == 401
+      raise ApiRequestError, response.reason_phrase if response.status == 403
+    end
+  end
+end

data/lib/wetransfer/item.rb

@@ -0,0 +1,14 @@
+module WeTransfer
+  class Item
+    attr_accessor :id,
+                  :content_identifier,
+                  :local_identifier,
+                  :multipart_parts,
+                  :multipart_id,
+                  :name,
+                  :size,
+                  :upload_url,
+                  :upload_id,
+                  :path
+  end
+end

data/lib/wetransfer/item_builder.rb

@@ -0,0 +1,59 @@
+module WeTransfer
+  class ItemBuilder
+    class FileDoesNotExistError < ArgumentError; end
+    attr_reader :item
+
+    def initialize(item: nil)
+      @item = if item.nil?
+                Item.new
+              else
+                item
+              end
+    end
+
+    def path(path:)
+      @item.path = path
+    end
+
+    def content_identifier
+      @item.content_identifier = 'file'
+    end
+
+    def local_identifier
+      # only take the file name and shorten it to 36 characters if it's longer
+      @item.local_identifier = @item.path.split('/').last.gsub(' ', '')[0..35]
+    end
+
+    def name
+      @item.name = @item.path.split('/').last
+    end
+
+    def size
+      @item.size = File.size(@item.path)
+    end
+
+    def id(item:, id:)
+      item.id = id
+    end
+
+    def upload_url(item:, url:)
+      item.upload_url = [url]
+    end
+
+    def multipart_parts(item:, part_count:)
+      item.multipart_parts = part_count
+    end
+
+    def multipart_id(item:, multi_id:)
+      item.multipart_id = multi_id
+    end
+
+    def upload_id(item:, upload_id:)
+      item.upload_id = upload_id
+    end
+
+    def validate_file
+      raise FileDoesNotExistError, "#{@item} does not exist" unless File.exist?(@item.path)
+    end
+  end
+end

data/lib/wetransfer/transfer.rb

@@ -0,0 +1,30 @@
+module WeTransfer
+  class Transfer
+    attr_accessor :id, :name, :description, :shortened_url, :items
+
+    def initialize
+      @items = []
+    end
+
+    def transfer_params
+      {
+        name: name,
+        description: description,
+        items: items_params
+      }
+    end
+
+    def items_params
+      transfer_items = []
+      items.each do |item|
+        transfer_items << {
+          local_identifier: item.local_identifier,
+          content_identifier: item.content_identifier,
+          filename: item.name,
+          filesize: item.size
+        }
+      end
+      transfer_items
+    end
+  end
+end

data/lib/wetransfer/transfer_builder.rb

@@ -0,0 +1,28 @@
+module WeTransfer
+  class TransferBuilder
+    def initialize(transfer: nil)
+      @transfer = if transfer.nil?
+                    Transfer.new
+                  else
+                    transfer
+                  end
+    end
+
+    def name_description(name: nil, description: nil)
+      @transfer.name = name || "File Transfer: #{Time.now.strftime('%d-%m-%Y')}"
+      @transfer.description = description || 'Transfer generated with WeTransfer Ruby SDK'
+    end
+
+    def self.id(transfer:, id:)
+      transfer.id = id
+    end
+
+    def self.shortened_url(transfer:, url:)
+      transfer.shortened_url = url
+    end
+
+    def transfer
+      @transfer
+    end
+  end
+end

data/lib/wetransfer/version.rb

@@ -0,0 +1,3 @@
+module WeTransfer
+  VERSION = '0.1.0'.freeze
+end

data/spec/client_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe WeTransfer::Client do
+  describe 'Client#new' do
+    it 'returns a error when no api_key is given' do
+      expect {
+        described_class.new
+      }.to raise_error(ArgumentError, /missing keyword: api_key/)
+    end
+
+    it 'on initialization a active connection object is created' do
+      client = described_class.new(api_key: 'api-key')
+      expect(client.api_connection).to be_kind_of WeTransfer::Connection
+    end
+  end
+
+  describe 'Client#create_transfer' do
+    let(:client) { described_class.new(api_key: 'api-key') }
+
+    it 'create transfer should return a transfer object' do
+      transfer = client.create_transfer
+      expect(transfer.shortened_url).to start_with('http://we.tl/s-')
+      expect(transfer).to be_kind_of WeTransfer::Transfer
+    end
+
+    it 'when no name/description is send, a default name/description is generated' do
+      transfer = client.create_transfer
+      expect(transfer.name).to eq("File Transfer: #{Time.now.strftime('%d-%m-%Y')}")
+      expect(transfer.description).to eq('Transfer generated with WeTransfer Ruby SDK')
+    end
+
+    it 'when a name/description is send, transfer has that name/description' do
+      transfer = client.create_transfer(
+        name: 'WeTransfer Test Transfer',
+        description: "Moving along… Good news, everyone! I've
+        taught the toaster to feel love! Humans dating robots is
+        sick. You people wonder why I'm still single? It's 'cause
+        all the fine robot sisters are dating humans!")
+      expect(transfer.name).to eq('WeTransfer Test Transfer')
+      expect(transfer.description).to start_with('Moving along… Good news, everyone!')
+    end
+
+    it 'when no items are send, a itemless transfer is created' do
+      transfer = client.create_transfer
+      expect(transfer.items).to be_empty
+    end
+
+    it 'when items are sended, the transfer has items' do
+      transfer = client.create_transfer(items: ["#{__dir__}/fixtures/war-and-peace.txt"])
+      expect(transfer).to be_kind_of WeTransfer::Transfer
+      expect(transfer.items.count).to eq(1)
+    end
+
+    it 'returns an error when items are not sended inside an array' do
+      expect {
+        client.create_transfer(items: "#{__dir__}/war-end-peace.txt")
+      }.to raise_error(StandardError, 'The items field must be an array')
+    end
+
+    it 'completes a item after item upload' do
+      transfer = client.create_transfer(items: ["#{__dir__}/fixtures/war-and-peace.txt"])
+      expect(transfer).to be_kind_of WeTransfer::Transfer
+    end
+  end
+
+  describe 'Client#add_item' do
+    let(:client) { described_class.new(api_key: 'api-key') }
+
+    it 'add items to an already created transfer' do
+      transfer = client.create_transfer
+      expect(transfer.items.count).to eq(0)
+      transfer = client.add_items(transfer: transfer, items: ["#{__dir__}/fixtures/war-and-peace.txt"])
+      expect(transfer.items.count).to eq(1)
+    end
+
+    it 'raises an error when no transfer is being send to add_items_to_transfer method' do
+      expect {
+        client.add_items(items: ["#{__dir__}/fixtures/war-and-peace.txt"])
+        }.to raise_error(ArgumentError, 'missing keyword: transfer')
+    end
+  end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe WeTransfer::Connection do
+  describe 'Connection#new' do
+    it 'creates a new connection when the client is passed' do
+      client = OpenStruct.new(api_key: 'api-key-12345')
+      connection = described_class.new(client: client)
+      expect(connection.api_connection).to be_kind_of Faraday::Connection
+    end
+
+    it 'contains the api_key inside the connection' do
+      client = OpenStruct.new(api_key: 'api-key-12345')
+      connection = described_class.new(client: client)
+      expect(connection.api_key).to eq(client.api_key)
+    end
+
+    it 'correctly handles the connection path variable' do
+      ENV['WT_API_CONNECTION_PATH'] = '/this_path_does_not_exist'
+      client = OpenStruct.new(api_key: 'api-key-12345')
+      connection = described_class.new(client: client)
+      expect(connection.api_path).to eq('/this_path_does_not_exist')
+      ENV['WT_API_CONNECTION_PATH'] = '/v1'
+      connection = described_class.new(client: client)
+      expect(connection.api_path).to eq('/v1')
+    end
+  end
+
+  describe 'Connection#post_request' do
+    it 'returns with a response body when a post request is made' do
+      client = OpenStruct.new(api_key: 'api-key-12345')
+      connection = described_class.new(client: client)
+      response = connection.post_request(path: '/authorize')
+      expect(response['status']).to eq('success')
+    end
+
+    it 'returns with a response body when a post request is made' do
+      client = OpenStruct.new(api_key: 'api-key-12345')
+      connection = described_class.new(client: client)
+      response = connection.post_request(path: '/transfers', body: {name: 'test_transfer', description: 'this is a test transfer', items: []})
+      expect(response['shortened_url']).to start_with('http://we.tl/s-')
+      expect(response['name']).to eq('test_transfer')
+      expect(response['description']).to eq('this is a test transfer')
+      expect(response['items'].count).to eq(0)
+    end
+
+    it 'returns with a ApiRequestError when request is forbidden' do
+      client = OpenStruct.new(api_key: 'api-key-12345')
+      connection = described_class.new(client: client)
+      expect {
+        connection.post_request(path: '/forbidden')
+      }.to raise_error(WeTransfer::Connection::ApiRequestError, 'Forbidden')
+    end
+  end
+
+  describe 'Connection#get_request' do
+    it 'returns with a response body when a get request is made for upload urls' do
+      client = OpenStruct.new(api_key: 'api-key-12345')
+      connection = described_class.new(client: client)
+      response = connection.get_request(path: '/files/1337/uploads/1/7331')
+      expect(response['upload_url']).to include('upload')
+      expect(response['part_number']).to eq(1)
+      expect(response['upload_id']).to_not be_nil
+      expect(response['upload_expires_at']).to_not be_nil
+    end
+
+    it 'returns with a ApiRequestError when request is forbidden' do
+      client = OpenStruct.new(api_key: 'api-key-12345')
+      connection = described_class.new(client: client)
+      expect {
+        connection.get_request(path: '/forbidden')
+      }.to raise_error(WeTransfer::Connection::ApiRequestError, 'Forbidden')
+    end
+  end
+end