wj-mailgun-ruby 1.1.7

data/lib/mailgun/response.rb

@@ -0,0 +1,62 @@
+require 'ostruct'
+
+module Mailgun
+  # A Mailgun::Response object is instantiated for each response generated
+  # by the Client request. The Response object supports deserialization of
+  # the JSON result. Or, if you prefer JSON or YAML formatting, call the
+  # method for conversion.
+  #
+  # See the Github documentation for full examples.
+  class Response
+    # All responses have a payload and a code corresponding to http, though
+    #   slightly different
+    attr_accessor :body, :code
+
+    def self.from_hash(h)
+      # Create a "fake" response object with the data passed from h
+      self.new OpenStruct.new(h)
+    end
+
+    def initialize(response)
+      @body = response.body
+      @code = response.code
+    end
+
+    # Return response as Ruby Hash
+    #
+    # @return [Hash] A standard Ruby Hash containing the HTTP result.
+
+    def to_h
+      JSON.parse(@body)
+    rescue => err
+      raise ParseError.new(err), err
+    end
+
+    # Replace @body with Ruby Hash
+    #
+    # @return [Hash] A standard Ruby Hash containing the HTTP result.
+    def to_h!
+      @body = JSON.parse(@body)
+    rescue => err
+      raise ParseError.new(err), err
+    end
+
+    # Return response as Yaml
+    #
+    # @return [String] A string containing response as YAML
+    def to_yaml
+      YAML.dump(to_h)
+    rescue => err
+      raise ParseError.new(err), err
+    end
+
+    # Replace @body with YAML
+    #
+    # @return [String] A string containing response as YAML
+    def to_yaml!
+      @body = YAML.dump(to_h)
+    rescue => err
+      raise ParseError.new(err), err
+    end
+  end
+end

data/lib/mailgun/suppressions.rb

@@ -0,0 +1,270 @@
+require 'uri'
+
+require 'mailgun/exceptions/exceptions'
+
+module Mailgun
+
+  # The Mailgun::Suppressions object makes it easy to manage "suppressions"
+  # attached to an account. "Suppressions" means bounces, unsubscribes, and complaints.
+  class Suppressions
+
+    # @param [Mailgun::Client] client API client to use for requests
+    # @param [String] domain Domain name to use for the suppression endpoints.
+    def initialize(client, domain)
+      @client = client
+      @domain = domain
+
+      @paging_next = nil
+      @paging_prev = nil
+    end
+
+    ####
+    # Paging operations
+    ####
+
+    def next
+      response = get_from_paging @paging_next[:path], @paging_next[:params]
+      extract_paging response
+      response
+    end
+
+    def prev
+      response = get_from_paging @paging_prev[:path], @paging_prev[:params]
+      extract_paging response
+      response
+    end
+
+    ####
+    # Bounces Endpoint (/v3/:domain/bounces)
+    ####
+
+    def list_bounces(params = {})
+      response = @client.get("#{@domain}/bounces", params)
+      extract_paging response
+      response
+    end
+
+    def get_bounce(address)
+      @client.get("#{@domain}/bounces/#{address}", nil)
+    end
+
+    def create_bounce(params = {})
+      @client.post("#{@domain/bounces}", params)
+    end
+
+    # Creates multiple bounces on the Mailgun API.
+    # If a bounce does not have a valid structure, it will be added to a list of unsendable bounces.
+    # The list of unsendable bounces will be returned at the end of this operation.
+    #
+    # If more than 999 bounce entries are provided, the list will be split and recursive calls will be made.
+    #
+    # @param [Array] data Array of bounce hashes
+    # @return [Response] Mailgun API response
+    # @return [Array] Return values from recursive call for list split.
+    def create_bounces(data)
+      # `data` should be a list of hashes, with each hash containing *at least* an `address` key.
+      split_return = []
+      if data.length >= 1000 then
+        resp, resp_l = create_bounces data[999..-1]
+        split_return.push(resp)
+        split_return.concat(resp_l)
+        data = data[0..998]
+      elsif data.length == 0 then
+        return nil, []
+      end
+
+      valid = []
+      # Validate the bounces given
+      # NOTE: `data` could potentially be very large (1000 elements) so it is
+      # more efficient to pop from data and push into a different array as
+      # opposed to possibly copying the entire array to another array.
+      while not data.empty? do
+        bounce = data.pop
+        # Bounces MUST contain a `address` key.
+        if not bounce.include? :address then
+          raise Mailgun::ParameterError.new "Bounce MUST include a :address key: #{bounce}"
+        end
+
+        bounce.each do |k, v|
+          # Hash values MUST be strings.
+          if not v.is_a? String then
+            bounce[k] = v.to_s
+          end
+        end
+
+        valid.push bounce
+      end
+
+      response = @client.post("#{@domain}/bounces", valid.to_json, { "Content-Type" => "application/json" })
+      return response, split_return
+    end
+
+    def delete_bounce(address)
+      @client.delete("#{@domain}/bounces/#{address}")
+    end
+
+    def delete_all_bounces
+      @client.delete("#{@domain}/bounces")
+    end
+
+    ####
+    # Unsubscribes Endpoint (/v3/:domain/unsubscribes)
+    ####
+
+    def list_unsubscribes(params = {})
+      response = @client.get("#{@domain}/unsubscribes", params)
+      extract_paging response
+      response
+    end
+
+    def get_unsubscribe(address)
+      @client.get("#{@domain}/unsubscribes/#{address}")
+    end
+
+    def create_unsubscribe(params = {})
+      @client.post("#{@domain}/unsubscribes", params)
+    end
+
+    # Creates multiple unsubscribes on the Mailgun API.
+    # If an unsubscribe does not have a valid structure, it will be added to a list of unsendable unsubscribes.
+    # The list of unsendable unsubscribes will be returned at the end of this operation.
+    #
+    # If more than 999 unsubscribe entries are provided, the list will be split and recursive calls will be made.
+    #
+    # @param [Array] data Array of unsubscribe hashes
+    # @return [Response] Mailgun API response
+    # @return [Array] Return values from recursive call for list split.
+    def create_unsubscribes(data)
+      # `data` should be a list of hashes, with each hash containing *at least* an `address` key.
+      split_return = []
+      if data.length >= 1000 then
+        resp, resp_l = create_unsubscribes data[999..-1]
+        split_return.push(resp)
+        split_return.concat(resp_l)
+        data = data[0..998]
+      elsif data.length == 0 then
+        return nil, []
+      end
+
+      valid = []
+      # Validate the unsubscribes given
+      while not data.empty? do
+        unsubscribe = data.pop
+        # unsubscribes MUST contain a `address` key.
+        if not unsubscribe.include? :address then
+          raise Mailgun::ParameterError.new "Unsubscribe MUST include a :address key: #{unsubscribe}"
+        end
+
+        unsubscribe.each do |k, v|
+          # Hash values MUST be strings.
+          if not v.is_a? String then
+            unsubscribe[k] = v.to_s
+          end
+        end
+
+        valid.push unsubscribe
+      end
+
+      response = @client.post("#{@domain}/unsubscribes", valid.to_json, { "Content-Type" => "application/json" })
+      return response, split_return
+    end
+
+    def delete_unsubscribe(address, params = {})
+      @client.delete("#{@domain}/unsubscribes/#{address}")
+    end
+
+    ####
+    # Complaints Endpoint (/v3/:domain/complaints)
+    ####
+
+    def list_complaints(params = {})
+      response = @client.get("#{@domain}/complaints", params)
+      extract_paging response
+      response
+    end
+
+    def get_complaint(address)
+      @client.get("#{@domain}/complaints/#{address}", nil)
+    end
+
+    def create_complaint(params = {})
+      @client.post("#{@domain}/complaints", params)
+    end
+
+    # Creates multiple complaints on the Mailgun API.
+    # If a complaint does not have a valid structure, it will be added to a list of unsendable complaints.
+    # The list of unsendable complaints will be returned at the end of this operation.
+    #
+    # If more than 999 complaint entries are provided, the list will be split and recursive calls will be made.
+    #
+    # @param [Array] data Array of complaint hashes
+    # @return [Response] Mailgun API response
+    # @return [Array] Return values from recursive call for list split.
+    def create_complaints(data)
+      # `data` should be a list of hashes, with each hash containing *at least* an `address` key.
+      split_return = []
+      if data.length >= 1000 then
+        resp, resp_l = create_complaints data[999..-1]
+        split_return.push(resp)
+        split_return.concat(resp_l)
+        data = data[0..998]
+      elsif data.length == 0 then
+        return nil, []
+      end
+
+      valid = []
+      # Validate the complaints given
+      while not data.empty? do
+        complaint = data.pop
+        # complaints MUST contain a `address` key.
+        if not complaint.include? :address then
+          raise Mailgun::ParameterError.new "Complaint MUST include a :address key: #{complaint}"
+        end
+
+        complaint.each do |k, v|
+          # Hash values MUST be strings.
+          if not v.is_a? String then
+            complaint[k] = v.to_s
+          end
+        end
+
+        valid.push complaint
+      end
+
+      response = @client.post("#{@domain}/complaints", valid.to_json, { "Content-Type" => "application/json" })
+      return response, split_return
+    end
+
+    def delete_complaint(address)
+      @client.delete("#{@domain}/complaints/#{address}")
+    end
+
+    private
+
+    def get_from_paging(uri, params = {})
+      @client.get(uri, params)
+    end
+
+    def extract_paging(response)
+      rhash = response.to_h
+      return nil unless rhash.include? "paging"
+
+      page_info = rhash["paging"]
+
+      # Build the `next` endpoint
+      page_next = URI.parse(page_info["next"])
+      @paging_next = {
+        :path => page_next.path[/\/v[\d](.+)/, 1],
+        :params => Hash[URI.decode_www_form page_next.query],
+      }
+
+      # Build the `prev` endpoint
+      page_prev = URI.parse(page_info["previous"])
+      @paging_prev = {
+        :path => page_prev.path[/\/v[\d](.+)/, 1],
+        :params => Hash[URI.decode_www_form page_prev.query],
+      }
+    end
+
+  end
+end

data/lib/mailgun/version.rb

@@ -0,0 +1,4 @@
+# It's the version. Yeay!
+module Mailgun
+  VERSION = '1.1.7'
+end

data/lib/mailgun/webhooks/webhooks.rb

@@ -0,0 +1,101 @@
+module Mailgun
+
+  # A Mailgun::Webhooks object is a simple CRUD interface to Mailgun Webhooks.
+  # Uses Mailgun
+  class Webhooks
+
+    # Public creates a new Mailgun::Webhooks instance.
+    #   Defaults to Mailgun::Client
+    def initialize(client = Mailgun::Client.new)
+      @client = client
+    end
+
+    # Public: Get Webhooks
+    #
+    # domain  - a string the domain name to retrieve webhooks for
+    # options - a Hash of options
+    #
+    # Returns a Hash of the list of domains or nil
+    def list(domain, options = {})
+      res = @client.get("domains/#{domain}/webhooks", options)
+      res.to_h['webhooks']
+    end
+    alias_method :get_webhooks, :list
+
+    # Public: Get webook information for a specific action
+    #
+    # domain - a String of Domain name to find a webhook url for
+    # action - a String identifying the webhook to get the URL for
+    #
+    # Returns a String of the url for the identified webhook or an
+    #   empty String if one is not set
+    def info(domain, action)
+      res = @client.get("domains/#{domain}/webhooks/#{action}")
+      res.to_h['webhook']['url'] || ''
+    rescue NoMethodError
+      ''
+    end
+    alias_method :get_webhook_url, :info
+
+    # Public: Add webhook
+    #
+    # domain - A String of the domain name (ex. domain.com)
+    # action - A String of the action to create a webhook for
+    # url    - A String of the url of the webhook
+    #
+    # Returns a Boolean of whether the webhook was created
+    def create(domain, action, url = '')
+      res = @client.post("domains/#{domain}/webhooks", id: action, url: url)
+      res.to_h['webhook']['url'] == url && res.to_h[message] == 'Webhook has been created'
+    end
+    alias_method :add, :create
+    alias_method :add_webhook, :create
+
+    # Public: Sets all webhooks to the same URL
+    #
+    # domain - A String of the domain name
+    # url    - A String of the url to set all webhooks to
+    #
+    # Returns true or false
+    def create_all(domain, url = '')
+      %w(bounce click deliver drop open spam unsubscribe).each do |action|
+        add_webhook domain, action, url
+      end
+      true
+    rescue
+      false
+    end
+    alias_method :add_all_webhooks, :create_all
+
+    # Public: Delete a specific webhook
+    #
+    # domain - The required String of domain name
+    # action - The required String of the webhook action to delete
+    #
+    # Returns a Boolean of the success
+    def remove(domain, action)
+      fail Mailgun::ParameterError('Domain not provided to remove webhook from') unless domain
+      fail Mailgun::ParameterError('Action not provided to identify webhook to remove') unless action
+      @client.delete("domains/#{domain}/webhooks/#{action}").to_h['message'] == 'Webhook has been deleted'
+    rescue Mailgun::CommunicationError
+      false
+    end
+    alias_method :delete, :remove
+    alias_method :delete_webhook, :remove
+
+    # Public: Delete all webhooks for a domain
+    #
+    # domain - A required String of the domain to remove all webhooks for
+    #
+    # Returns a Boolean on the success
+    def remove_all(domain)
+      fail Mailgun::ParameterError('Domain not provided to remove webhooks from') unless domain
+      %w(bounce click deliver drop open spam unsubscribe).each do |action|
+        delete_webhook domain, action
+      end
+    end
+    alias_method :delete_all, :remove_all
+    alias_method :delete_all_webooks, :remove_all
+
+  end
+end

data/lib/railgun.rb

@@ -0,0 +1,8 @@
+require 'railgun/railtie'
+require 'railgun/attachment'
+require 'railgun/errors'
+require 'railgun/mailer'
+require 'railgun/message'
+
+module Railgun
+end