sendgrid4r 1.8.1 → 1.10.0

data/lib/sendgrid4r/rest/cancel_scheduled_sends.rb

@@ -1,89 +1,70 @@
 # -*- encoding: utf-8 -*-
 
-module SendGrid4r
-  module REST
-    #
-    # SendGrid Web API v3 CancelScheduledSends
-    #
-    module CancelScheduledSends
-      include SendGrid4r::REST::Request
+module SendGrid4r::REST
+  #
+  # SendGrid Web API v3 CancelScheduledSends
+  #
+  module CancelScheduledSends
+    include Request
 
-      ScheduledSend = Struct.new(:batch_id, :status)
+    ScheduledSend = Struct.new(:batch_id, :status)
 
-      def self.batch_url(batch_id = nil)
-        url = "#{BASE_URL}/mail/batch"
-        url = "#{url}/#{batch_id}" unless batch_id.nil?
-        url
-      end
+    def self.batch_url(batch_id = nil)
+      url = "#{BASE_URL}/mail/batch"
+      url = "#{url}/#{batch_id}" unless batch_id.nil?
+      url
+    end
 
-      def self.scheduled_sends_url(batch_id = nil)
-        url = "#{BASE_URL}/user/scheduled_sends"
-        url = "#{url}/#{batch_id}" unless batch_id.nil?
-        url
-      end
+    def self.scheduled_sends_url(batch_id = nil)
+      url = "#{BASE_URL}/user/scheduled_sends"
+      url = "#{url}/#{batch_id}" unless batch_id.nil?
+      url
+    end
 
-      def self.create_scheduled_sends(resp)
-        return resp if resp.nil?
-        scheduled_sends = []
-        resp.each do |scheduled_send|
-          scheduled_sends.push(
-            SendGrid4r::REST::CancelScheduledSends.create_scheduled_send(
-              scheduled_send
-            )
-          )
-        end
-        scheduled_sends
+    def self.create_scheduled_sends(resp)
+      return resp if resp.nil?
+      resp.map do |scheduled_send|
+        CancelScheduledSends.create_scheduled_send(scheduled_send)
       end
+    end
 
-      def self.create_scheduled_send(resp)
-        return resp if resp.nil?
-        ScheduledSend.new(resp['batch_id'], resp['status'])
-      end
+    def self.create_scheduled_send(resp)
+      return resp if resp.nil?
+      ScheduledSend.new(resp['batch_id'], resp['status'])
+    end
 
-      def generate_batch_id(&block)
-        endpoint = SendGrid4r::REST::CancelScheduledSends.batch_url
-        resp = post(@auth, endpoint, nil, &block)
-        SendGrid4r::REST::CancelScheduledSends.create_scheduled_send(resp)
-      end
+    def generate_batch_id(&block)
+      resp = post(@auth, CancelScheduledSends.batch_url, nil, &block)
+      CancelScheduledSends.create_scheduled_send(resp)
+    end
 
-      def validate_batch_id(batch_id:, &block)
-        endpoint = SendGrid4r::REST::CancelScheduledSends.batch_url(batch_id)
-        resp = get(@auth, endpoint, nil, &block)
-        SendGrid4r::REST::CancelScheduledSends.create_scheduled_send(resp)
-      end
+    def validate_batch_id(batch_id:, &block)
+      resp = get(@auth, CancelScheduledSends.batch_url(batch_id), nil, &block)
+      CancelScheduledSends.create_scheduled_send(resp)
+    end
 
-      def post_scheduled_send(batch_id:, status:, &block)
-        endpoint = SendGrid4r::REST::CancelScheduledSends.scheduled_sends_url
-        payload = {}
-        payload['batch_id'] = batch_id
-        payload['status'] = status
-        resp = post(@auth, endpoint, payload, &block)
-        SendGrid4r::REST::CancelScheduledSends.create_scheduled_send(resp)
-      end
+    def post_scheduled_send(batch_id:, status:, &block)
+      endpoint = CancelScheduledSends.scheduled_sends_url
+      payload = { batch_id: batch_id, status: status }
+      resp = post(@auth, endpoint, payload, &block)
+      CancelScheduledSends.create_scheduled_send(resp)
+    end
 
-      def get_scheduled_sends(batch_id: nil, &block)
-        endpoint = SendGrid4r::REST::CancelScheduledSends.scheduled_sends_url(
-          batch_id
-        )
-        resp = get(@auth, endpoint, nil, nil, &block)
-        SendGrid4r::REST::CancelScheduledSends.create_scheduled_sends(resp)
-      end
+    def get_scheduled_sends(batch_id: nil, &block)
+      endpoint = CancelScheduledSends.scheduled_sends_url(batch_id)
+      resp = get(@auth, endpoint, nil, nil, &block)
+      CancelScheduledSends.create_scheduled_sends(resp)
+    end
 
-      def patch_scheduled_send(batch_id:, status:, &block)
-        endpoint = SendGrid4r::REST::CancelScheduledSends.scheduled_sends_url(
-          batch_id
-        )
-        payload = {}
-        payload['status'] = status
-        patch(@auth, endpoint, payload, &block)
-      end
+    def patch_scheduled_send(batch_id:, status:, &block)
+      endpoint = CancelScheduledSends.scheduled_sends_url(batch_id)
+      payload = { status: status }
+      patch(@auth, endpoint, payload, &block)
+    end
 
-      def delete_scheduled_send(batch_id:, &block)
-        endpoint = SendGrid4r::REST::CancelScheduledSends.scheduled_sends_url(
-          batch_id
-        )
-        delete(@auth, endpoint, nil, &block)
-      end
+    def delete_scheduled_send(batch_id:, &block)
+      endpoint = CancelScheduledSends.scheduled_sends_url(batch_id)
+      delete(@auth, endpoint, nil, &block)
     end
   end
 end

data/lib/sendgrid4r/rest/categories.rb

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+
+module SendGrid4r::REST
+  #
+  # SendGrid Web API v3 Categories
+  #
+  module Categories
+    include Request
+
+    Category = Struct.new(:category)
+
+    def self.create_category(resp)
+      return resp if resp.nil?
+      Category.new(resp['category'])
+    end
+
+    def self.create_categories(resp)
+      return resp if resp.nil?
+      resp.map { |category| Categories.create_category(category) }
+    end
+
+    def get_categories(category: nil, limit: nil, offset: nil, &block)
+      params = {}
+      params['category'] = category unless category.nil?
+      params['limit'] = limit unless limit.nil?
+      params['offset'] = offset unless limit.nil?
+      resp = get(@auth, "#{BASE_URL}/categories", params, &block)
+      Categories.create_categories(resp)
+    end
+  end
+end

data/lib/sendgrid4r/rest/email_activity.rb

@@ -0,0 +1,72 @@
+# -*- encoding: utf-8 -*-
+
+module SendGrid4r::REST
+  #
+  # SendGrid Web API v3 EmailActivity
+  #
+  module EmailActivity
+    include Request
+
+    #
+    # SendGrid Web API v3 Event - AggregatedBy
+    #
+    module Event
+      BOUNCES = 'bounces'
+      CLICKS = 'clicks'
+      DEFERRED = 'deferred'
+      DELIVERED = 'delivered'
+      DROPS = 'drops'
+      GROUP_UNSUBSCRIBE = 'group_unsubscribe'
+      GROUP_RESUBSCRIBE = 'group_resubscribe'
+      OPENS = 'opens'
+      PROCESSED = 'processed'
+      PARSEAPI = 'parseapi'
+      SPAM_REPORTS = 'spam_reports'
+      UNSUBSCRIBE = 'unsubscribes'
+    end
+
+    Activity = Struct.new(
+      :email, :event, :created, :category, :smtp_id, :asm_group_id,
+      :msg_id, :ip, :url, :reason
+    )
+
+    def self.url
+      "#{BASE_URL}/email_activity"
+    end
+
+    def self.create_activities(resp)
+      return resp if resp.nil?
+      resp.map { |activity| EmailActivity.create_activity(activity) }
+    end
+
+    def self.create_activity(resp)
+      return resp if resp.nil?
+      Activity.new(
+        resp['email'],
+        resp['event'],
+        resp['created'].nil? ? nil : Time.at(resp['created']),
+        resp['category'],
+        resp['smtp_id'],
+        resp['asm_group_id'],
+        resp['msg_id'],
+        resp['ip'],
+        resp['url'],
+        resp['reason']
+      )
+    end
+
+    def get_email_activities(
+      email: nil, events: nil, exclude_events: nil, start_time: nil,
+      end_time: nil, &block
+    )
+      params = {}
+      params['email'] = email unless email.nil?
+      params['events'] = events unless events.nil?
+      params['exclude_events'] = exclude_events unless exclude_events.nil?
+      params['start_time'] = start_time.to_i unless start_time.nil?
+      params['end_time'] = end_time.to_i unless end_time.nil?
+      resp = get(@auth, EmailActivity.url, params, &block)
+      EmailActivity.create_activities(resp)
+    end
+  end
+end

data/lib/sendgrid4r/rest/invalid_emails.rb

@@ -1,81 +1,63 @@
 # -*- encoding: utf-8 -*-
 
-module SendGrid4r
-  module REST
-    #
-    # SendGrid Web API v3 InvalidEmails
-    #
-    module InvalidEmails
-      include SendGrid4r::REST::Request
-
-      InvalidEmail = Struct.new(
-        :created, :email, :reason
-      )
-
-      def self.url(email = nil)
-        url = "#{BASE_URL}/suppression/invalid_emails"
-        url = "#{url}/#{email}" unless email.nil?
-        url
-      end
+module SendGrid4r::REST
+  #
+  # SendGrid Web API v3 InvalidEmails
+  #
+  module InvalidEmails
+    include Request
+
+    InvalidEmail = Struct.new(:created, :email, :reason)
+
+    def self.url(email = nil)
+      url = "#{BASE_URL}/suppression/invalid_emails"
+      url = "#{url}/#{email}" unless email.nil?
+      url
+    end
 
-      def self.create_invalid_emails(resp)
-        return resp if resp.nil?
-        invalid_emails = []
-        resp.each do |invalid_email|
-          invalid_emails.push(
-            SendGrid4r::REST::InvalidEmails.create_invalid_email(invalid_email)
-          )
-        end
-        invalid_emails
+    def self.create_invalid_emails(resp)
+      return resp if resp.nil?
+      resp.map do |invalid_email|
+        InvalidEmails.create_invalid_email(invalid_email)
       end
+    end
 
-      def self.create_invalid_email(resp)
-        return resp if resp.nil?
-        created = Time.at(resp['created']) unless resp['created'].nil?
-        InvalidEmail.new(
-          created,
-          resp['email'],
-          resp['reason']
-        )
-      end
+    def self.create_invalid_email(resp)
+      return resp if resp.nil?
+      created = Time.at(resp['created']) unless resp['created'].nil?
+      InvalidEmail.new(created, resp['email'], resp['reason'])
+    end
 
-      def get_invalid_emails(
-        start_time: nil, end_time: nil, limit: nil, offset: nil, &block
-      )
-        params = {}
-        params['start_time'] = start_time.to_i unless start_time.nil?
-        params['end_time'] = end_time.to_i unless end_time.nil?
-        params['limit'] = limit.to_i unless limit.nil?
-        params['offset'] = offset.to_i unless offset.nil?
-        resp = get(@auth, SendGrid4r::REST::InvalidEmails.url, params, &block)
-        SendGrid4r::REST::InvalidEmails.create_invalid_emails(resp)
-      end
+    def get_invalid_emails(
+      start_time: nil, end_time: nil, limit: nil, offset: nil, &block
+    )
+      params = {}
+      params[:start_time] = start_time.to_i unless start_time.nil?
+      params[:end_time] = end_time.to_i unless end_time.nil?
+      params[:limit] = limit.to_i unless limit.nil?
+      params[:offset] = offset.to_i unless offset.nil?
+      resp = get(@auth, InvalidEmails.url, params, &block)
+      InvalidEmails.create_invalid_emails(resp)
+    end
 
-      def delete_invalid_emails(delete_all: nil, emails: nil, &block)
-        endpoint = SendGrid4r::REST::InvalidEmails.url
-        payload = {}
-        if delete_all == true
-          payload['delete_all'] = delete_all
-        else
-          payload['emails'] = emails
-        end
-        delete(@auth, endpoint, nil, payload, &block)
+    def delete_invalid_emails(delete_all: nil, emails: nil, &block)
+      if delete_all
+        payload = { delete_all: delete_all }
+      else
+        payload = { emails: emails }
       end
+      delete(@auth, InvalidEmails.url, nil, payload, &block)
+    end
 
-      def get_invalid_email(email:, &block)
-        endpoint = SendGrid4r::REST::InvalidEmails.url(email)
-        params = {}
-        params['email'] = email
-        resp = get(@auth, endpoint, params, &block)
-        SendGrid4r::REST::InvalidEmails.create_invalid_emails(resp)
-      end
+    def get_invalid_email(email:, &block)
+      params = { email: email }
+      resp = get(@auth, InvalidEmails.url(email), params, &block)
+      InvalidEmails.create_invalid_emails(resp)
+    end
 
-      def delete_invalid_email(email:, &block)
-        endpoint = SendGrid4r::REST::InvalidEmails.url(email)
-        params = {}
-        params['email'] = email
-        delete(@auth, endpoint, params, &block)
-      end
+    def delete_invalid_email(email:, &block)
+      params = { email: email }
+      delete(@auth, InvalidEmails.url(email), params, &block)
     end
   end
 end

data/lib/sendgrid4r/rest/ip_access_management.rb

@@ -1,134 +1,109 @@
 # -*- encoding: utf-8 -*-
 
-module SendGrid4r
-  module REST
-    #
-    # SendGrid Web API v3 IpAccessManagement
-    #
-    module IpAccessManagement
-      include SendGrid4r::REST::Request
-
-      IpActivities = Struct.new(:result)
-
-      IpActivity = Struct.new(
-        :allowed, :auth_method, :first_at, :ip, :last_at, :location
-      )
+module SendGrid4r::REST
+  #
+  # SendGrid Web API v3 IpAccessManagement
+  #
+  module IpAccessManagement
+    include Request
 
-      WhitelistedIps = Struct.new(:result)
+    IpActivities = Struct.new(:result)
 
-      WhitelistedIp = Struct.new(:result)
+    IpActivity = Struct.new(
+      :allowed, :auth_method, :first_at, :ip, :last_at, :location
+    )
 
-      WhitelistedIpResult = Struct.new(:id, :ip, :created_at, :updated_at)
+    WhitelistedIps = Struct.new(:result)
 
-      def self.url_activity
-        "#{BASE_URL}/access_settings/activity"
-      end
+    WhitelistedIp = Struct.new(:result)
 
-      def self.url_whitelist(rule_id = nil)
-        url = "#{BASE_URL}/access_settings/whitelist"
-        url = "#{url}/#{rule_id}" unless rule_id.nil?
-        url
-      end
+    WhitelistedIpResult = Struct.new(:id, :ip, :created_at, :updated_at)
 
-      def self.create_ip_activities(resp)
-        return resp if resp.nil?
-        result = []
-        resp['result'].each do |activity|
-          result.push(
-            SendGrid4r::REST::IpAccessManagement.create_ip_activity(activity)
-          )
-        end
-        IpActivities.new(result)
-      end
+    def self.url_activity
+      "#{BASE_URL}/access_settings/activity"
+    end
 
-      def self.create_ip_activity(resp)
-        return resp if resp.nil?
-        first_at = Time.at(resp['first_at']) unless resp['first_at'].nil?
-        last_at = Time.at(resp['last_at']) unless resp['last_at'].nil?
-        IpActivity.new(
-          resp['allowed'],
-          resp['auth_method'],
-          first_at,
-          resp['ip'],
-          last_at,
-          resp['location']
-        )
-      end
+    def self.url_whitelist(rule_id = nil)
+      url = "#{BASE_URL}/access_settings/whitelist"
+      url = "#{url}/#{rule_id}" unless rule_id.nil?
+      url
+    end
 
-      def self.create_whitelisted_ips(resp)
-        return resp if resp.nil?
-        result = []
-        resp['result'].each do |whitelisted_ip|
-          result.push(
-            SendGrid4r::REST::IpAccessManagement.create_whitelisted_ip_result(
-              whitelisted_ip
-            )
-          )
-        end
-        WhitelistedIps.new(result)
+    def self.create_ip_activities(resp)
+      return resp if resp.nil?
+      result = resp['result'].map do |activity|
+        IpAccessManagement.create_ip_activity(activity)
       end
+      IpActivities.new(result)
+    end
 
-      def self.create_whitelisted_ip(resp)
-        return resp if resp.nil?
-        WhitelistedIp.new(
-          SendGrid4r::REST::IpAccessManagement.create_whitelisted_ip_result(
-            resp['result']
-          )
-        )
-      end
+    def self.create_ip_activity(resp)
+      return resp if resp.nil?
+      first_at = Time.at(resp['first_at']) unless resp['first_at'].nil?
+      last_at = Time.at(resp['last_at']) unless resp['last_at'].nil?
+      IpActivity.new(
+        resp['allowed'],
+        resp['auth_method'],
+        first_at,
+        resp['ip'],
+        last_at,
+        resp['location']
+      )
+    end
 
-      def self.create_whitelisted_ip_result(resp)
-        return resp if resp.nil?
-        created_at = Time.at(resp['created_at']) unless resp['created_at'].nil?
-        updated_at = Time.at(resp['updated_at']) unless resp['updated_at'].nil?
-        WhitelistedIpResult.new(resp['id'], resp['ip'], created_at, updated_at)
+    def self.create_whitelisted_ips(resp)
+      return resp if resp.nil?
+      result = resp['result'].map do |whitelisted_ip|
+        IpAccessManagement.create_whitelisted_ip_result(whitelisted_ip)
       end
+      WhitelistedIps.new(result)
+    end
 
-      def get_ip_activities(limit: nil, &block)
-        endpoint = SendGrid4r::REST::IpAccessManagement.url_activity
-        params = {}
-        params['limit'] = limit unless limit.nil?
-        resp = get(@auth, endpoint, params, &block)
-        SendGrid4r::REST::IpAccessManagement.create_ip_activities(resp)
-      end
+    def self.create_whitelisted_ip(resp)
+      return resp if resp.nil?
+      WhitelistedIp.new(
+        IpAccessManagement.create_whitelisted_ip_result(resp['result'])
+      )
+    end
 
-      def get_whitelisted_ips(&block)
-        endpoint = SendGrid4r::REST::IpAccessManagement.url_whitelist
-        resp = get(@auth, endpoint, &block)
-        SendGrid4r::REST::IpAccessManagement.create_whitelisted_ips(resp)
-      end
+    def self.create_whitelisted_ip_result(resp)
+      return resp if resp.nil?
+      created_at = Time.at(resp['created_at']) unless resp['created_at'].nil?
+      updated_at = Time.at(resp['updated_at']) unless resp['updated_at'].nil?
+      WhitelistedIpResult.new(resp['id'], resp['ip'], created_at, updated_at)
+    end
 
-      def post_whitelisted_ips(ips:, &block)
-        endpoint = SendGrid4r::REST::IpAccessManagement.url_whitelist
-        ips_param = []
-        ips.each do |ip|
-          ip_param = {}
-          ip_param['ip'] = ip
-          ips_param.push(ip_param)
-        end
-        params = {}
-        params['ips'] = ips_param
-        resp = post(@auth, endpoint, params, &block)
-        SendGrid4r::REST::IpAccessManagement.create_whitelisted_ips(resp)
-      end
+    def get_ip_activities(limit: nil, &block)
+      params = {}
+      params[:limit] = limit unless limit.nil?
+      resp = get(@auth, IpAccessManagement.url_activity, params, &block)
+      IpAccessManagement.create_ip_activities(resp)
+    end
 
-      def delete_whitelisted_ips(ids:, &block)
-        endpoint = SendGrid4r::REST::IpAccessManagement.url_whitelist
-        payload = {}
-        payload['ids'] = ids
-        delete(@auth, endpoint, nil, payload, &block)
-      end
+    def get_whitelisted_ips(&block)
+      resp = get(@auth, IpAccessManagement.url_whitelist, &block)
+      IpAccessManagement.create_whitelisted_ips(resp)
+    end
 
-      def get_whitelisted_ip(rule_id:, &block)
-        endpoint = SendGrid4r::REST::IpAccessManagement.url_whitelist(rule_id)
-        resp = get(@auth, endpoint, nil, &block)
-        SendGrid4r::REST::IpAccessManagement.create_whitelisted_ip(resp)
-      end
+    def post_whitelisted_ips(ips:, &block)
+      ips_param = ips.map { |ip| { ip: ip } }
+      params = { ips: ips_param }
+      resp = post(@auth, IpAccessManagement.url_whitelist, params, &block)
+      IpAccessManagement.create_whitelisted_ips(resp)
+    end
 
-      def delete_whitelisted_ip(rule_id:, &block)
-        endpoint = SendGrid4r::REST::IpAccessManagement.url_whitelist(rule_id)
-        delete(@auth, endpoint, nil, &block)
-      end
+    def delete_whitelisted_ips(ids:, &block)
+      payload = { ids: ids }
+      delete(@auth, IpAccessManagement.url_whitelist, nil, payload, &block)
+    end
+
+    def get_whitelisted_ip(rule_id:, &block)
+      resp = get(@auth, IpAccessManagement.url_whitelist(rule_id), nil, &block)
+      IpAccessManagement.create_whitelisted_ip(resp)
+    end
+
+    def delete_whitelisted_ip(rule_id:, &block)
+      delete(@auth, IpAccessManagement.url_whitelist(rule_id), nil, &block)
     end
   end
 end