sendgrid4r 1.8.1 → 1.10.0

data/lib/sendgrid4r/rest/{contacts → marketing_campaigns/contacts}/custom_fields.rb

@@ -1,13 +1,13 @@
 # -*- encoding: utf-8 -*-
 
-module SendGrid4r
-  module REST
+module SendGrid4r::REST
+  module MarketingCampaigns
     module Contacts
       #
       # SendGrid Web API v3 Contacts - Custom Fields
       #
       module CustomFields
-        include SendGrid4r::REST::Request
+        include Request
 
         Field = Struct.new(:id, :name, :type, :value) do
           def eql?(other)
@@ -34,11 +34,8 @@ module SendGrid4r
 
         def self.create_fields(resp)
           return resp if resp.nil?
-          custom_fields = []
-          resp['custom_fields'].each do |field|
-            custom_fields.push(
-              SendGrid4r::REST::Contacts::CustomFields.create_field(field)
-            )
+          custom_fields = resp['custom_fields'].map do |field|
+            Contacts::CustomFields.create_field(field)
           end
           Fields.new(custom_fields)
         end
@@ -47,34 +44,22 @@ module SendGrid4r
           params = {}
           params['name'] = name
           params['type'] = type
-          resp = post(
-            @auth, SendGrid4r::REST::Contacts::CustomFields.url, params, &block
-          )
-          SendGrid4r::REST::Contacts::CustomFields.create_field(resp)
+          resp = post(@auth, Contacts::CustomFields.url, params, &block)
+          Contacts::CustomFields.create_field(resp)
         end
 
         def get_custom_fields(&block)
-          resp = get(
-            @auth, SendGrid4r::REST::Contacts::CustomFields.url, &block
-          )
-          SendGrid4r::REST::Contacts::CustomFields.create_fields(resp)
+          resp = get(@auth, Contacts::CustomFields.url, &block)
+          Contacts::CustomFields.create_fields(resp)
         end
 
         def get_custom_field(custom_field_id:, &block)
-          resp = get(
-            @auth,
-            SendGrid4r::REST::Contacts::CustomFields.url(custom_field_id),
-            &block
-          )
-          SendGrid4r::REST::Contacts::CustomFields.create_field(resp)
+          resp = get(@auth, Contacts::CustomFields.url(custom_field_id), &block)
+          Contacts::CustomFields.create_field(resp)
         end
 
         def delete_custom_field(custom_field_id:, &block)
-          delete(
-            @auth,
-            SendGrid4r::REST::Contacts::CustomFields.url(custom_field_id),
-            &block
-          )
+          delete(@auth, Contacts::CustomFields.url(custom_field_id), &block)
         end
       end
     end

data/lib/sendgrid4r/rest/{contacts → marketing_campaigns/contacts}/lists.rb

@@ -1,13 +1,13 @@
 # -*- encoding: utf-8 -*-
 
-module SendGrid4r
-  module REST
+module SendGrid4r::REST
+  module MarketingCampaigns
     module Contacts
       #
       # SendGrid Web API v3 Contacts - Lists
       #
       module Lists
-        include SendGrid4r::REST::Request
+        include Request
 
         List = Struct.new(:id, :name, :recipient_count)
         Lists = Struct.new(:lists)
@@ -19,7 +19,7 @@ module SendGrid4r
         end
 
         def self.recipients_url(list_id, recipient_id = nil)
-          url = "#{SendGrid4r::REST::Contacts::Lists.url(list_id)}/recipients"
+          url = "#{Contacts::Lists.url(list_id)}/recipients"
           url = "#{url}/#{recipient_id}" unless recipient_id.nil?
           url
         end
@@ -31,50 +31,41 @@ module SendGrid4r
 
         def self.create_lists(resp)
           return resp if resp.nil?
-          lists = []
-          resp['lists'].each do |list|
-            lists.push(SendGrid4r::REST::Contacts::Lists.create_list(list))
-          end
+          lists = resp['lists'].map { |list| Contacts::Lists.create_list(list) }
           Lists.new(lists)
         end
 
         def post_list(name:, &block)
           params = {}
           params['name'] = name
-          resp = post(
-            @auth, SendGrid4r::REST::Contacts::Lists.url, params, &block
-          )
-          SendGrid4r::REST::Contacts::Lists.create_list(resp)
+          resp = post(@auth, Contacts::Lists.url, params, &block)
+          Contacts::Lists.create_list(resp)
         end
 
         def get_lists(&block)
-          resp = get(@auth, SendGrid4r::REST::Contacts::Lists.url, &block)
-          SendGrid4r::REST::Contacts::Lists.create_lists(resp)
+          resp = get(@auth, Contacts::Lists.url, &block)
+          Contacts::Lists.create_lists(resp)
         end
 
         def get_list(list_id:, &block)
-          resp = get(
-            @auth, SendGrid4r::REST::Contacts::Lists.url(list_id), &block
-          )
-          SendGrid4r::REST::Contacts::Lists.create_list(resp)
+          resp = get(@auth, Contacts::Lists.url(list_id), &block)
+          Contacts::Lists.create_list(resp)
         end
 
         def patch_list(list_id:, name:, &block)
           params = {}
           params['name'] = name
-          endpoint = SendGrid4r::REST::Contacts::Lists.url(list_id)
-          resp = patch(@auth, endpoint, params, &block)
-          SendGrid4r::REST::Contacts::Lists.create_list(resp)
+          resp = patch(@auth, Contacts::Lists.url(list_id), params, &block)
+          Contacts::Lists.create_list(resp)
         end
 
         def delete_list(list_id:, &block)
-          delete(@auth, SendGrid4r::REST::Contacts::Lists.url(list_id), &block)
+          delete(@auth, Contacts::Lists.url(list_id), &block)
         end
 
         # no bodies returned
         def post_recipients_to_list(list_id:, recipients:, &block)
-          url = SendGrid4r::REST::Contacts::Lists.url(list_id)
-          endpoint = "#{url}/recipients"
+          endpoint = "#{Contacts::Lists.url(list_id)}/recipients"
           post(@auth, endpoint, recipients, &block)
         end
 
@@ -84,28 +75,23 @@ module SendGrid4r
           params = {}
           params['page'] = page unless page.nil?
           params['page_size'] = page_size unless page_size.nil?
-          endpoint = SendGrid4r::REST::Contacts::Lists.recipients_url(list_id)
+          endpoint = Contacts::Lists.recipients_url(list_id)
           resp = get(@auth, endpoint, params, &block)
-          SendGrid4r::REST::Contacts::Recipients.create_recipients(resp)
+          Contacts::Recipients.create_recipients(resp)
         end
 
         def post_recipient_to_list(list_id:, recipient_id:, &block)
-          endpoint = SendGrid4r::REST::Contacts::Lists.recipients_url(
-            list_id, recipient_id
-          )
+          endpoint = Contacts::Lists.recipients_url(list_id, recipient_id)
           post(@auth, endpoint, &block)
         end
 
         def delete_recipient_from_list(list_id:, recipient_id:, &block)
-          endpoint = SendGrid4r::REST::Contacts::Lists.recipients_url(
-            list_id, recipient_id
-          )
+          endpoint = Contacts::Lists.recipients_url(list_id, recipient_id)
           delete(@auth, endpoint, &block)
         end
 
         def delete_lists(list_ids:, &block)
-          endpoint = "#{BASE_URL}/contactdb/lists"
-          delete(@auth, endpoint, nil, list_ids, &block)
+          delete(@auth, "#{BASE_URL}/contactdb/lists", nil, list_ids, &block)
         end
       end
     end

data/lib/sendgrid4r/rest/marketing_campaigns/contacts/recipients.rb

@@ -0,0 +1,134 @@
+# -*- encoding: utf-8 -*-
+
+module SendGrid4r::REST
+  module MarketingCampaigns
+    module Contacts
+      #
+      # SendGrid Web API v3 Contacts - Recipients
+      #
+      module Recipients
+        include Request
+
+        Recipient = Struct.new(
+          :created_at,
+          :custom_fields,
+          :email,
+          :first_name,
+          :id,
+          :last_clicked,
+          :last_emailed,
+          :last_name,
+          :last_opened,
+          :updated_at
+        )
+
+        Recipients = Struct.new(:recipients)
+
+        def self.create_recipient(resp)
+          return resp if resp.nil?
+          custom_fields = []
+          custom_fields = resp['custom_fields'].map do |field|
+            Contacts::CustomFields.create_field(field)
+          end unless resp['custom_fields'].nil?
+          Recipient.new(
+            Time.at(resp['created_at']), custom_fields,
+            resp['email'], resp['first_name'], resp['id'],
+            resp['last_clicked'], resp['last_emailed'],
+            resp['last_name'], resp['last_opened'],
+            Time.at(resp['updated_at'])
+          )
+        end
+
+        def self.create_recipients(resp)
+          return resp if resp.nil?
+          recipients = resp['recipients'].map do |recipient|
+            Contacts::Recipients.create_recipient(recipient)
+          end
+          Recipients.new(recipients)
+        end
+
+        def self.url(recipient_id = nil)
+          url = "#{BASE_URL}/contactdb/recipients"
+          url = "#{url}/#{recipient_id}" unless recipient_id.nil?
+          url
+        end
+
+        def post_recipients(params:, &block)
+          resp = post(@auth, Contacts::Recipients.url, params, &block)
+          Contacts::Recipients.create_result(resp)
+        end
+
+        def patch_recipients(params:, &block)
+          resp = patch(@auth, Contacts::Recipients.url, params, &block)
+          Contacts::Recipients.create_result(resp)
+        end
+
+        def delete_recipients(recipient_ids:, &block)
+          delete(@auth, Contacts::Recipients.url, nil, recipient_ids, &block)
+        end
+
+        def get_recipients(page: nil, page_size: nil, &block)
+          params = {}
+          params['page_size'] = page_size unless page_size.nil?
+          params['page'] = page unless page.nil?
+          resp = get(@auth, Contacts::Recipients.url, params, &block)
+          Contacts::Recipients.create_recipients(resp)
+        end
+
+        def get_recipient(recipient_id:, &block)
+          resp = get(@auth, Contacts::Recipients.url(recipient_id), &block)
+          Contacts::Recipients.create_recipient(resp)
+        end
+
+        def delete_recipient(recipient_id:, &block)
+          delete(@auth, Contacts::Recipients.url(recipient_id), &block)
+        end
+
+        def get_lists_recipient_belong(recipient_id:, &block)
+          resp = get(
+            @auth, "#{Contacts::Recipients.url(recipient_id)}/lists", &block
+          )
+          Contacts::Lists.create_lists(resp)
+        end
+
+        def get_recipients_count(&block)
+          resp = get(@auth, "#{Contacts::Recipients.url}/count", &block)
+          resp['recipient_count'] unless resp.nil?
+        end
+
+        def search_recipients(params:, &block)
+          endpoint = "#{Contacts::Recipients.url}/search"
+          resp = get(@auth, endpoint, params, &block)
+          Contacts::Recipients.create_recipients(resp)
+        end
+
+        Result = Struct.new(
+          :error_count,
+          :error_indices,
+          :new_count,
+          :persisted_recipients,
+          :updated_count,
+          :errors
+        )
+
+        def self.create_result(resp)
+          return resp if resp.nil?
+          errors = resp['errors'].map do |error|
+            Contacts::Recipients.create_error(error)
+          end unless resp['errors'].nil?
+          Result.new(
+            resp['error_count'], resp['error_indices'], resp['new_count'],
+            resp['persisted_recipients'], resp['updated_count'], errors
+          )
+        end
+
+        Error = Struct.new(:error_indices, :message)
+
+        def self.create_error(resp)
+          return resp if resp.nil?
+          Error.new(resp['error_indices'], resp['message'])
+        end
+      end
+    end
+  end
+end

data/lib/sendgrid4r/rest/{contacts → marketing_campaigns/contacts}/reserved_fields.rb

@@ -1,13 +1,13 @@
 # -*- encoding: utf-8 -*-
 
-module SendGrid4r
-  module REST
+module SendGrid4r::REST
+  module MarketingCampaigns
     module Contacts
       #
       # SendGrid Web API v3 Contacts - Reserved Fields
       #
       module ReservedFields
-        include SendGrid4r::REST::Request
+        include Request
 
         Field = Struct.new(:name, :type) do
           def eql?(other)
@@ -23,11 +23,8 @@ module SendGrid4r
 
         def self.create_fields(resp)
           return resp if resp.nil?
-          reserved_fields = []
-          resp['reserved_fields'].each do |field|
-            reserved_fields.push(
-              SendGrid4r::REST::Contacts::ReservedFields.create_field(field)
-            )
+          reserved_fields = resp['reserved_fields'].map do |field|
+            Contacts::ReservedFields.create_field(field)
           end
           Fields.new(reserved_fields)
         end
@@ -39,7 +36,7 @@ module SendGrid4r
 
         def get_reserved_fields(&block)
           resp = get(@auth, "#{BASE_URL}/contactdb/reserved_fields", &block)
-          SendGrid4r::REST::Contacts::ReservedFields.create_fields(resp)
+          Contacts::ReservedFields.create_fields(resp)
         end
       end
     end

data/lib/sendgrid4r/rest/marketing_campaigns/contacts/segments.rb

@@ -0,0 +1,86 @@
+# -*- encoding: utf-8 -*-
+
+module SendGrid4r::REST
+  module MarketingCampaigns
+    module Contacts
+      #
+      # SendGrid Web API v3 Contacts - Segments
+      #
+      module Segments
+        include Request
+
+        Condition = Struct.new(:field, :value, :operator, :and_or)
+        Segment = Struct.new(
+          :id, :name, :list_id, :conditions, :recipient_count
+        )
+        Segments = Struct.new(:segments)
+
+        def self.url(segment_id = nil)
+          url = "#{BASE_URL}/contactdb/segments"
+          url = "#{url}/#{segment_id}" unless segment_id.nil?
+          url
+        end
+
+        def self.create_condition(resp)
+          return resp if resp.nil?
+          Condition.new(
+            resp['field'], resp['value'], resp['operator'], resp['and_or']
+          )
+        end
+
+        def self.create_segment(resp)
+          return resp if resp.nil?
+          conditions = resp['conditions'].map do |condition|
+            Contacts::Segments.create_condition(condition)
+          end
+          Segment.new(
+            resp['id'],
+            resp['name'],
+            resp['list_id'],
+            conditions,
+            resp['recipient_count']
+          )
+        end
+
+        def self.create_segments(resp)
+          return resp if resp.nil?
+          segments = resp['segments'].map do |segment|
+            Contacts::Segments.create_segment(segment)
+          end
+          Segments.new(segments)
+        end
+
+        def post_segment(params:, &block)
+          resp = post(@auth, Contacts::Segments.url, params.to_h, &block)
+          Contacts::Segments.create_segment(resp)
+        end
+
+        def get_segments(&block)
+          resp = get(@auth, Contacts::Segments.url, &block)
+          Contacts::Segments.create_segments(resp)
+        end
+
+        def get_segment(segment_id:, &block)
+          resp = get(@auth, Contacts::Segments.url(segment_id), &block)
+          Contacts::Segments.create_segment(resp)
+        end
+
+        def patch_segment(segment_id:, params:, &block)
+          endpoint = Contacts::Segments.url(segment_id)
+          resp = patch(@auth, endpoint, params, &block)
+          Contacts::Segments.create_segment(resp)
+        end
+
+        def delete_segment(segment_id:, &block)
+          delete(@auth, Contacts::Segments.url(segment_id), &block)
+        end
+
+        def get_recipients_on_segment(segment_id:, &block)
+          endpoint = "#{Contacts::Segments.url(segment_id)}/recipients"
+          resp = get(@auth, endpoint, nil, &block)
+          Contacts::Recipients.create_recipients(resp)
+        end
+      end
+    end
+  end
+end

data/lib/sendgrid4r/rest/marketing_campaigns/marketing_campaigns.rb

@@ -0,0 +1,119 @@
+# -*- encoding: utf-8 -*-
+
+module SendGrid4r::REST
+  #
+  # SendGrid Web API v3 MarketingCampaigns
+  #
+  module MarketingCampaigns
+    include Request
+
+    Campaign = Struct.new(
+      :id, :title, :subject, :sender_id, :list_ids, :segment_ids,
+      :categories, :suppression_group_id, :custom_unsubscribe_url,
+      :ip_pool, :html_content, :plain_content, :send_at, :status
+    )
+
+    Campaigns = Struct.new(:result)
+
+    def self.create_campaign(resp)
+      return resp if resp.nil?
+      send_at = Time.at(resp['send_at']) unless resp['send_at'].nil?
+      Campaign.new(
+        resp['id'], resp['title'], resp['subject'], resp['sender_id'],
+        resp['list_ids'], resp['segment_ids'], resp['categories'],
+        resp['suppression_group_id'], resp['custom_unsubscribe_url'],
+        resp['ip_pool'], resp['html_content'], resp['plain_content'],
+        send_at, resp['status']
+      )
+    end
+
+    def self.create_campaigns(resp)
+      return resp if resp.nil?
+      result = resp['result'].map do |campaign|
+        MarketingCampaigns.create_campaign(campaign)
+      end
+      Campaigns.new(result)
+    end
+
+    def self.url(campaign_id = nil)
+      url = "#{BASE_URL}/campaigns"
+      url = "#{url}/#{campaign_id}" unless campaign_id.nil?
+      url
+    end
+
+    def post_campaign(params:, &block)
+      endpoint = MarketingCampaigns.url
+      resp = post(@auth, endpoint, params, &block)
+      MarketingCampaigns.create_campaign(resp)
+    end
+
+    def get_campaigns(&block)
+      endpoint = MarketingCampaigns.url
+      resp = get(@auth, endpoint, &block)
+      MarketingCampaigns.create_campaigns(resp)
+    end
+
+    def get_campaign(campaign_id:, &block)
+      endpoint = MarketingCampaigns.url(campaign_id)
+      resp = get(@auth, endpoint, &block)
+      MarketingCampaigns.create_campaign(resp)
+    end
+
+    def delete_campaign(campaign_id:, &block)
+      endpoint = MarketingCampaigns.url(campaign_id)
+      delete(@auth, endpoint, &block)
+    end
+
+    def patch_campaign(campaign_id:, params:, &block)
+      endpoint = MarketingCampaigns.url(campaign_id)
+      resp = patch(@auth, endpoint, params.to_h, &block)
+      MarketingCampaigns.create_campaign(resp)
+    end
+
+    def send_campaign(campaign_id:, &block)
+      endpoint = MarketingCampaigns.url(campaign_id)
+      endpoint = "#{endpoint}/schedules/now"
+      resp = post(@auth, endpoint, nil, &block)
+      MarketingCampaigns.create_campaign(resp)
+    end
+
+    def schedule_campaign(campaign_id:, send_at:, &block)
+      endpoint = MarketingCampaigns.url(campaign_id)
+      endpoint = "#{endpoint}/schedules"
+      payload = {}
+      payload['send_at'] = send_at.to_i
+      resp = post(@auth, endpoint, payload, &block)
+      MarketingCampaigns.create_campaign(resp)
+    end
+
+    def reschedule_campaign(campaign_id:, send_at:, &block)
+      endpoint = MarketingCampaigns.url(campaign_id)
+      endpoint = "#{endpoint}/schedules"
+      payload = {}
+      payload['send_at'] = send_at.to_i
+      resp = patch(@auth, endpoint, payload, &block)
+      MarketingCampaigns.create_campaign(resp)
+    end
+
+    def get_schedule_time_campaign(campaign_id:, &block)
+      endpoint = MarketingCampaigns.url(campaign_id)
+      endpoint = "#{endpoint}/schedules"
+      resp = get(@auth, endpoint, &block)
+      MarketingCampaigns.create_campaign(resp)
+    end
+
+    def unschedule_campaign(campaign_id:, &block)
+      endpoint = MarketingCampaigns.url(campaign_id)
+      endpoint = "#{endpoint}/schedules"
+      delete(@auth, endpoint, &block)
+    end
+
+    def test_campaign(campaign_id:, to:, &block)
+      endpoint = MarketingCampaigns.url(campaign_id)
+      endpoint = "#{endpoint}/schedules/test"
+      payload = {}
+      payload['to'] = to
+      post(@auth, endpoint, payload, &block)
+    end
+  end
+end

data/lib/sendgrid4r/rest/marketing_campaigns/senders.rb

@@ -0,0 +1,101 @@
+# -*- encoding: utf-8 -*-
+
+module SendGrid4r::REST
+  #
+  # SendGrid Web API v3 MarketingCampaigns
+  #
+  module MarketingCampaigns
+    include Request
+
+    Sender = Struct.new(
+      :id, :nickname, :from, :reply_to, :address, :address_2, :city, :state,
+      :zip, :country, :verified, :updated_at, :created_at, :locked
+    ) do
+      def from=(from)
+        tap { |s| s[:from] = from.to_h }
+      end
+
+      def reply_to=(reply_to)
+        tap { |s| s[:reply_to] = reply_to.to_h }
+      end
+
+      def to_h
+        super.reject { |_key, value| value.nil? }
+      end
+    end
+
+    Address = Struct.new(:email, :name)
+
+    Verified = Struct.new(:status, :reason)
+
+    def self.create_sender(resp)
+      return resp if resp.nil?
+      from = MarketingCampaigns.create_address(resp['from'])
+      reply_to = MarketingCampaigns.create_address(resp['reply_to'])
+      verified = MarketingCampaigns.create_verified(resp['verified'])
+      Sender.new(
+        resp['id'], resp['nickname'], from, reply_to, resp['address'],
+        resp['address_2'], resp['city'], resp['state'], resp['zip'],
+        resp['country'], verified, Time.at(resp['updated_at']),
+        Time.at(resp['created_at']), resp['locked']
+      )
+    end
+
+    def self.create_senders(resp)
+      return resp if resp.nil?
+      resp.map do |sender|
+        MarketingCampaigns.create_sender(sender)
+      end
+    end
+
+    def self.create_address(resp)
+      return resp if resp.nil?
+      Address.new(resp['email'], resp['name'])
+    end
+
+    def self.create_verified(resp)
+      return resp if resp.nil?
+      Verified.new(resp['status'], resp['reason'])
+    end
+
+    def self.url_sender(sender_id = nil)
+      url = "#{BASE_URL}/senders"
+      url = "#{url}/#{sender_id}" unless sender_id.nil?
+      url
+    end
+
+    def post_sender(params:, &block)
+      endpoint = MarketingCampaigns.url_sender
+      resp = post(@auth, endpoint, params.to_h, &block)
+      MarketingCampaigns.create_sender(resp)
+    end
+
+    def get_senders(&block)
+      endpoint = MarketingCampaigns.url_sender
+      resp = get(@auth, endpoint, &block)
+      MarketingCampaigns.create_senders(resp)
+    end
+
+    def patch_sender(sender_id:, params:, &block)
+      endpoint = MarketingCampaigns.url_sender(sender_id)
+      resp = patch(@auth, endpoint, params.to_h, &block)
+      MarketingCampaigns.create_sender(resp)
+    end
+
+    def delete_sender(sender_id:, &block)
+      endpoint = MarketingCampaigns.url_sender(sender_id)
+      delete(@auth, endpoint, &block)
+    end
+
+    def resend_sender_verification(sender_id:, &block)
+      endpoint = MarketingCampaigns.url_sender(sender_id)
+      post(@auth, "#{endpoint}/resend_verification", nil, &block)
+    end
+
+    def get_sender(sender_id:, &block)
+      endpoint = MarketingCampaigns.url_sender(sender_id)
+      resp = get(@auth, endpoint, &block)
+      MarketingCampaigns.create_sender(resp)
+    end
+  end
+end