fopost 0.2.0 → 0.3.0

data/lib/fopost/client.rb

@@ -3,12 +3,25 @@
 require 'fopost/http/client'
 require 'fopost/models'
 require 'fopost/resources/base'
+require 'fopost/resources/account_groups'
 require 'fopost/resources/accounts'
 require 'fopost/resources/ads'
+require 'fopost/resources/analytics'
+require 'fopost/resources/blog'
+require 'fopost/resources/google_ads'
 require 'fopost/resources/ai'
+require 'fopost/resources/broadcasts'
+require 'fopost/resources/contacts'
+require 'fopost/resources/google_business'
 require 'fopost/resources/inbox'
+require 'fopost/resources/activity'
+require 'fopost/resources/knowledge'
 require 'fopost/resources/labels'
+require 'fopost/resources/media'
 require 'fopost/resources/posts'
+require 'fopost/resources/blogs'
+require 'fopost/resources/validate'
+require 'fopost/resources/whatsapp'
 require 'fopost/resources/workspaces'
 
 module Fopost
@@ -23,7 +36,9 @@ module Fopost
   class Client
     DEFAULT_BASE_URL = HTTP::Client::DEFAULT_BASE_URL
 
-    attr_reader :posts, :accounts, :workspaces, :labels, :ai, :inbox, :ads
+    attr_reader :posts, :accounts, :account_groups, :workspaces, :labels, :ai, :inbox, :contacts, :broadcasts,
+                :sequences, :knowledge, :ads, :validate, :media, :activity, :google_business, :analytics,
+                :blog, :blogs, :whatsapp
 
     def initialize(api_key: nil, base_url: DEFAULT_BASE_URL, timeout: HTTP::Client::DEFAULT_TIMEOUT,
                    max_retries: HTTP::Client::DEFAULT_MAX_RETRIES, transport: nil, sleeper: nil)
@@ -44,11 +59,24 @@ module Fopost
 
       @posts = Resources::Posts.new(@http)
       @accounts = Resources::Accounts.new(@http)
+      @account_groups = Resources::AccountGroups.new(@http)
       @workspaces = Resources::Workspaces.new(@http)
       @labels = Resources::Labels.new(@http)
       @ai = Resources::Ai.new(@http)
       @inbox = Resources::Inbox.new(@http)
+      @contacts = Resources::Contacts.new(@http)
+      @broadcasts = Resources::Broadcasts.new(@http)
+      @sequences = Resources::Sequences.new(@http)
+      @knowledge = Resources::Knowledge.new(@http)
       @ads = Resources::Ads.new(@http)
+      @validate = Resources::Validate.new(@http)
+      @whatsapp = Resources::Whatsapp.new(@http)
+      @media = Resources::Media.new(@http)
+      @analytics = Resources::Analytics.new(@http)
+      @activity = Resources::Activity.new(@http)
+      @google_business = Resources::GoogleBusiness.new(@http)
+      @blog = Resources::Blog.new(@http)
+      @blogs = Resources::Blogs.new(@http)
     end
 
     def base_url

data/lib/fopost/errors.rb

@@ -56,6 +56,30 @@ module Fopost
   # 404 — no such resource, or it is outside the key's reach.
   class NotFoundError < Error; end
 
+  # 413 — the file is over the account's upload ceiling. {#max_file_bytes} is
+  # the largest file it may upload; {#upgrade_url} is where a bigger one is unlocked.
+  class FileTooLargeError < Error
+    def max_file_bytes
+      integer_field('max_file_bytes')
+    end
+
+    def file_bytes
+      integer_field('file_bytes')
+    end
+
+    def upgrade_url
+      value = body.is_a?(Hash) ? (body['upgrade_url'] || body[:upgrade_url]) : nil
+      value.is_a?(String) ? value : nil
+    end
+
+    private
+
+    def integer_field(name)
+      value = body.is_a?(Hash) ? (body[name] || body[name.to_sym]) : nil
+      value.is_a?(Integer) ? value : nil
+    end
+  end
+
   # 429 — rate limit exceeded. {#retry_after} is in seconds when the API sends it.
   class RateLimitError < Error
     attr_reader :retry_after
@@ -74,6 +98,7 @@ module Fopost
       402 => PaymentRequiredError,
       403 => PermissionDeniedError,
       404 => NotFoundError,
+      413 => FileTooLargeError,
       422 => ValidationError,
       429 => RateLimitError
     }.freeze

data/lib/fopost/file_part.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Fopost
+  # A file handed to `posts.create(files: ...)`: a path, an IO, or a Hash of
+  # `filename:` plus `io:` or `data:` and `mime_type:`.
+  class FilePart
+    MIME_TYPES = {
+      'png' => 'image/png', 'jpg' => 'image/jpeg', 'jpeg' => 'image/jpeg', 'gif' => 'image/gif',
+      'webp' => 'image/webp', 'heic' => 'image/heic', 'mp4' => 'video/mp4', 'mov' => 'video/quicktime',
+      'webm' => 'video/webm', 'm4v' => 'video/x-m4v', 'avi' => 'video/x-msvideo'
+    }.freeze
+
+    attr_reader :filename, :mime_type
+
+    def self.from(value)
+      case value
+      when FilePart then value
+      when String then new(filename: File.basename(value), path: value)
+      when Hash then from_hash(value)
+      else
+        raise ArgumentError, "fopost: cannot read a file from #{value.inspect}" unless value.respond_to?(:read)
+
+        new(filename: value.respond_to?(:path) && value.path ? File.basename(value.path) : nil, io: value)
+      end
+    end
+
+    def self.from_hash(hash)
+      hash = hash.transform_keys(&:to_sym)
+      new(filename: hash[:filename], mime_type: hash[:mime_type], io: hash[:io], data: hash[:data])
+    end
+
+    def initialize(filename:, mime_type: nil, path: nil, io: nil, data: nil)
+      raise ArgumentError, 'fopost: a file needs a filename' if filename.nil? || filename.to_s.empty?
+      raise ArgumentError, "fopost: a file needs io: or data: (#{filename})" if path.nil? && io.nil? && data.nil?
+
+      @filename = filename.to_s
+      @path = path
+      @io = io
+      @data = data&.b
+      @mime_type = mime_type || guess_mime_type
+    end
+
+    def size
+      return @data.bytesize if @data
+      return File.size(@path) if @path
+      return @io.size if @io.respond_to?(:size) && @io.size
+
+      data.bytesize
+    end
+
+    # The bytes, read once and kept.
+    def data
+      @data ||= (@path ? File.binread(@path) : @io.read.to_s.b)
+    end
+
+    # The post media `type` the API expects for this file.
+    def media_type
+      return 'gif' if mime_type == 'image/gif'
+      return 'video' if mime_type.start_with?('video/')
+
+      'image'
+    end
+
+    private
+
+    def guess_mime_type
+      extension = File.extname(@filename).delete_prefix('.').downcase
+      MIME_TYPES.fetch(extension) do
+        raise ArgumentError, "fopost: cannot guess the mime type of #{@filename}; pass mime_type:"
+      end
+    end
+  end
+end

data/lib/fopost/http/client.rb

@@ -7,6 +7,7 @@ require 'uri'
 require 'fopost/errors'
 require 'fopost/version'
 require 'fopost/http/net_http_transport'
+require 'fopost/http/multipart'
 
 module Fopost
   module HTTP
@@ -45,14 +46,21 @@ module Fopost
       end
 
       # Send a request, retrying on 429, and return the decoded body.
-      def request(method, path, json: nil, params: nil)
+      # `multipart` is `{ fields: {name => string}, parts: [Multipart::Part] }`.
+      def request(method, path, json: nil, params: nil, multipart: nil)
         url = build_url(path, params)
-        body = json.nil? ? nil : JSON.generate(json)
+        request_headers = headers
+        body = nil
+        if multipart
+          body, request_headers['Content-Type'] = Multipart.encode(multipart[:fields] || {}, multipart[:parts] || [])
+        elsif !json.nil?
+          body = JSON.generate(json)
+        end
 
         attempt = 0
         loop do
           attempt += 1
-          response = @transport.call(method: method.to_s.upcase, url: url, headers: headers, body: body)
+          response = @transport.call(method: method.to_s.upcase, url: url, headers: request_headers, body: body)
 
           if response.status == 429 && attempt < @max_retries
             wait = retry_after_seconds(response)
@@ -76,10 +84,31 @@ module Fopost
         request(:put, path, json: json)
       end
 
+      def patch(path, json = nil)
+        request(:patch, path, json: json)
+      end
+
       def delete(path, json = nil)
         request(:delete, path, json: json)
       end
 
+      def post_multipart(path, fields:, parts:)
+        request(:post, path, multipart: { fields: fields, parts: parts })
+      end
+
+      def put_multipart(path, fields:, parts:)
+        request(:put, path, multipart: { fields: fields, parts: parts })
+      end
+
+      # PUT raw bytes to a presigned URL. Sends only the headers given, never
+      # the API key, and returns nothing: the body is the storage backend's.
+      def put_raw(url, body, headers)
+        response = @transport.call(method: 'PUT', url: URI.parse(url.to_s), headers: headers, body: body)
+        return if response.success?
+
+        raise ErrorFactory.build(response.status, decode_body(response))
+      end
+
       # Peel the `{"data": ...}` envelope the API wraps most responses in. Some
       # endpoints (POST /posts, GET /posts/:id) return the resource bare, so the
       # envelope comes off only when it is actually there.
@@ -96,7 +125,10 @@ module Fopost
         query = (params || {}).compact
         unless query.empty?
           existing = uri.query.to_s
-          encoded = URI.encode_www_form(query.map { |k, v| [k.to_s, v.to_s] })
+          # An Array repeats the bare parameter, which is how the API reads a
+          # multi-valued filter like `daily_metrics`.
+          pairs = query.flat_map { |k, v| Array(v).map { |item| [k.to_s, item.to_s] } }
+          encoded = URI.encode_www_form(pairs)
           uri.query = existing.empty? ? encoded : "#{existing}&#{encoded}"
         end
         uri

data/lib/fopost/http/multipart.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Fopost
+  module HTTP
+    # Encodes a multipart/form-data body from string fields and file parts.
+    module Multipart
+      Part = Struct.new(:name, :filename, :mime_type, :data, keyword_init: true)
+
+      # Returns `[body, content_type]`; `body` is a binary String.
+      def self.encode(fields, parts)
+        boundary = "fopost#{SecureRandom.hex(16)}"
+        body = String.new(encoding: Encoding::BINARY)
+
+        fields.each do |name, value|
+          body << "--#{boundary}\r\n"
+          body << "Content-Disposition: form-data; name=\"#{name}\"\r\n\r\n"
+          body << value.to_s.b << "\r\n"
+        end
+
+        parts.each do |part|
+          body << "--#{boundary}\r\n"
+          body << "Content-Disposition: form-data; name=\"#{part.name}\"; filename=\"#{quote(part.filename)}\"\r\n"
+          body << "Content-Type: #{part.mime_type}\r\n\r\n"
+          body << part.data.b << "\r\n"
+        end
+
+        body << "--#{boundary}--\r\n"
+        [body, "multipart/form-data; boundary=#{boundary}"]
+      end
+
+      def self.quote(value)
+        value.to_s.gsub(/["\r\n]/, '"' => '%22', "\r" => '', "\n" => '')
+      end
+    end
+  end
+end