sendgrid4r 0.2.0 → 0.3.0

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

@@ -28,6 +28,7 @@ module SendGrid4r
         Recipients = Struct.new(:recipients)
 
         def self.create_recipient(resp)
+          return resp if resp.nil?
           custom_fields = []
           resp['custom_fields'].each do |field|
             custom_fields.push(
@@ -35,7 +36,7 @@ module SendGrid4r
             )
           end
           Recipient.new(
-            resp['created_at'],
+            Time.at(resp['created_at']),
             custom_fields,
             resp['email'],
             resp['first_name'],
@@ -44,11 +45,12 @@ module SendGrid4r
             resp['last_emailed'],
             resp['last_name'],
             resp['last_opend'],
-            resp['updated_at']
+            Time.at(resp['updated_at'])
           )
         end
 
         def self.create_recipients(resp)
+          return resp if resp.nil?
           recipients = []
           resp['recipients'].each do |recipient|
             recipients.push(
@@ -64,83 +66,91 @@ module SendGrid4r
           url
         end
 
-        def post_recipient(params)
-          resp = post(@auth, SendGrid4r::REST::Contacts::Recipients.url, params)
+        def post_recipient(params, &block)
+          resp = post(
+            @auth, SendGrid4r::REST::Contacts::Recipients.url, params, &block
+          )
           SendGrid4r::REST::Contacts::Recipients.create_recipient(resp)
         end
 
-        def delete_recipients(emails)
-          delete(@auth, SendGrid4r::REST::Contacts::Recipients.url, emails)
+        def delete_recipients(emails, &block)
+          delete(
+            @auth, SendGrid4r::REST::Contacts::Recipients.url, emails, &block
+          )
         end
 
-        def get_recipients(limit = nil, offset = nil)
+        def get_recipients(limit = nil, offset = nil, &block)
           params = {}
           params['limit'] = limit unless limit.nil?
           params['offset'] = offset unless offset.nil?
-          if params.length > 0
-            resp = get(
-              @auth, SendGrid4r::REST::Contacts::Recipients.url, params
-            )
-          else
-            resp = get(
-              @auth, SendGrid4r::REST::Contacts::Recipients.url
-            )
-          end
+          resp = get(
+            @auth, SendGrid4r::REST::Contacts::Recipients.url, params, &block
+          )
           SendGrid4r::REST::Contacts::Recipients.create_recipients(resp)
         end
 
-        def get_recipients_by_id(recipient_ids)
+        def get_recipients_by_id(recipient_ids, &block)
           resp = get(
             @auth,
             "#{SendGrid4r::REST::Contacts::Recipients.url}/batch",
             nil,
-            recipient_ids
+            recipient_ids,
+            &block
           )
           SendGrid4r::REST::Contacts::Recipients.create_recipients(resp)
         end
 
-        def get_recipients_count
+        def get_recipients_count(&block)
           resp = get(
-            @auth, "#{SendGrid4r::REST::Contacts::Recipients.url}/count")
-          resp['recipient_count']
+            @auth,
+            "#{SendGrid4r::REST::Contacts::Recipients.url}/count",
+            &block
+          )
+          resp['recipient_count'] unless resp.nil?
         end
 
-        def search_recipients(params)
+        def search_recipients(params, &block)
           resp = get(
             @auth,
             "#{SendGrid4r::REST::Contacts::Recipients.url}/search",
-            params
+            params,
+            &block
           )
           SendGrid4r::REST::Contacts::Recipients.create_recipients(resp)
         end
 
-        def get_recipient(recipient_id)
+        def get_recipient(recipient_id, &block)
           resp = get(
             @auth,
-            SendGrid4r::REST::Contacts::Recipients.url(recipient_id)
+            SendGrid4r::REST::Contacts::Recipients.url(recipient_id),
+            &block
           )
           SendGrid4r::REST::Contacts::Recipients.create_recipient(resp)
         end
 
-        def delete_recipient(recipient_id)
+        def delete_recipient(recipient_id, &block)
           delete(
-            @auth, SendGrid4r::REST::Contacts::Recipients.url(recipient_id)
+            @auth,
+            SendGrid4r::REST::Contacts::Recipients.url(recipient_id),
+            &block
           )
         end
 
-        def get_lists_recipient_belong(recipient_id)
+        def get_lists_recipient_belong(recipient_id, &block)
           resp = get(
             @auth,
-            "#{SendGrid4r::REST::Contacts::Recipients.url(recipient_id)}/lists"
+            "#{SendGrid4r::REST::Contacts::Recipients.url(recipient_id)}/lists",
+            &block
           )
           SendGrid4r::REST::Contacts::Lists.create_lists(resp)
         end
 
-        def post_recipients(recipients)
+        def post_recipients(recipients, &block)
           resp = post(
             @auth,
             "#{SendGrid4r::Client::BASE_URL}/contactdb/recipients_batch",
-            recipients
+            recipients,
+            &block
           )
           SendGrid4r::REST::Contacts::Recipients.create_result(resp)
         end
@@ -154,6 +164,7 @@ module SendGrid4r
         )
 
         def self.create_result(resp)
+          return resp if resp.nil?
           error_indices = []
           resp['error_indices'].each do |index|
             error_indices.push(index)

data/lib/sendgrid4r/rest/contacts/reserved_fields.rb

@@ -25,6 +25,7 @@ module SendGrid4r
         Fields = Struct.new(:reserved_fields)
 
         def self.create_fields(resp)
+          return resp if resp.nil?
           reserved_fields = []
           resp['reserved_fields'].each do |field|
             reserved_fields.push(
@@ -35,12 +36,15 @@ module SendGrid4r
         end
 
         def self.create_field(resp)
+          return resp if resp.nil?
           Field.new(resp['name'], resp['type'])
         end
 
-        def get_reserved_fields
+        def get_reserved_fields(&block)
           resp = get(
-            @auth, "#{SendGrid4r::Client::BASE_URL}/contactdb/reserved_fields"
+            @auth,
+            "#{SendGrid4r::Client::BASE_URL}/contactdb/reserved_fields",
+            &block
           )
           SendGrid4r::REST::Contacts::ReservedFields.create_fields(resp)
         end

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

@@ -27,12 +27,14 @@ module SendGrid4r
         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'].each do |condition|
             conditions.push(
@@ -49,6 +51,7 @@ module SendGrid4r
         end
 
         def self.create_segments(resp)
+          return resp if resp.nil?
           segments = []
           resp['segments'].each do |segment|
             segments.push(
@@ -58,42 +61,49 @@ module SendGrid4r
           Segments.new(segments)
         end
 
-        def post_segment(params)
+        def post_segment(params, &block)
           resp = post(
-            @auth, SendGrid4r::REST::Contacts::Segments.url, params.to_h
+            @auth, SendGrid4r::REST::Contacts::Segments.url, params.to_h, &block
           )
           SendGrid4r::REST::Contacts::Segments.create_segment(resp)
         end
 
-        def get_segments
-          resp = get(@auth, SendGrid4r::REST::Contacts::Segments.url)
+        def get_segments(&block)
+          resp = get(@auth, SendGrid4r::REST::Contacts::Segments.url, &block)
           SendGrid4r::REST::Contacts::Segments.create_segments(resp)
         end
 
-        def get_segment(segment_id)
+        def get_segment(segment_id, &block)
           resp = get(
-            @auth, SendGrid4r::REST::Contacts::Segments.url(segment_id)
+            @auth, SendGrid4r::REST::Contacts::Segments.url(segment_id), &block
           )
           SendGrid4r::REST::Contacts::Segments.create_segment(resp)
         end
 
-        def put_segment(segment_id, params)
+        def put_segment(segment_id, params, &block)
           resp = put(
-            @auth, SendGrid4r::REST::Contacts::Segments.url(segment_id), params
+            @auth,
+            SendGrid4r::REST::Contacts::Segments.url(segment_id),
+            params,
+            &block
           )
           SendGrid4r::REST::Contacts::Segments.create_segment(resp)
         end
 
-        def delete_segment(segment_id)
-          delete(@auth, SendGrid4r::REST::Contacts::Segments.url(segment_id))
+        def delete_segment(segment_id, &block)
+          delete(
+            @auth, SendGrid4r::REST::Contacts::Segments.url(segment_id), &block
+          )
         end
 
-        def get_recipients_from_segment(segment_id, limit = nil, offset = nil)
+        def get_recipients_from_segment(
+          segment_id, limit = nil, offset = nil, &block
+        )
           params = {}
           params['limit'] = limit unless limit.nil?
           params['offset'] = offset unless offset.nil?
           url = SendGrid4r::REST::Contacts::Segments.url(segment_id)
-          resp = get(@auth, "#{url}/recipients", params)
+          resp = get(@auth, "#{url}/recipients", params, &block)
           SendGrid4r::REST::Contacts::Recipients.create_recipients(resp)
         end
       end

data/lib/sendgrid4r/rest/ips/addresses.rb

@@ -18,54 +18,68 @@ module SendGrid4r
         Address = Struct.new(
           :ip, :pools, :warmup, :start_date, :subusers, :rdns, :pool_name)
 
+        def self.create_addresses(resp)
+          return resp if resp.nil?
+          ips = []
+          resp.each do |address|
+            ips.push(SendGrid4r::REST::Ips::Addresses.create_address(address))
+          end
+          ips
+        end
+
         def self.create_address(resp)
+          return resp if resp.nil?
           Address.new(
             resp['ip'],
             resp['pools'],
             resp['warmup'],
-            resp['start_date'],
+            resp['start_date'].nil? ? nil : Time.at(resp['start_date']),
             resp['subusers'],
             resp['rdns'],
             resp['pool_name']
           )
         end
 
-        def post_ip_to_pool(pool_name, ip)
+        def self.url(ip = nil)
+          url = "#{SendGrid4r::Client::BASE_URL}/ips"
+          url = "#{url}/#{ip}" unless ip.nil?
+          url
+        end
+
+        def post_ip_to_pool(pool_name, ip, &block)
           resp = post(
             @auth,
-            "#{SendGrid4r::Client::BASE_URL}/ips/pools/#{pool_name}/ips",
-            ip: ip
+            SendGrid4r::REST::Ips::Pools.url(pool_name, 'ips'),
+            ip: ip,
+            &block
           )
           SendGrid4r::REST::Ips::Addresses.create_address(resp)
         end
 
-        def get_ips
-          resp_a = get(@auth, "#{SendGrid4r::Client::BASE_URL}/ips")
-          ips = []
-          resp_a.each do |resp|
-            ips.push(SendGrid4r::REST::Ips::Addresses.create_address(resp))
-          end
-          ips
+        def get_ips(&block)
+          resp = get(@auth, SendGrid4r::REST::Ips::Addresses.url, &block)
+          SendGrid4r::REST::Ips::Addresses.create_addresses(resp)
         end
 
-        def get_ips_assigned
-          resp_a = get(@auth, "#{SendGrid4r::Client::BASE_URL}/ips/assigned")
-          ips = []
-          resp_a.each do |resp|
-            ips.push(SendGrid4r::REST::Ips::Addresses.create_address(resp))
-          end
-          ips
+        def get_ips_assigned(&block)
+          resp = get(
+            @auth, SendGrid4r::REST::Ips::Addresses.url('assigned'), &block
+          )
+          SendGrid4r::REST::Ips::Addresses.create_addresses(resp)
         end
 
-        def get_ip(ip)
-          resp = get(@auth, "#{SendGrid4r::Client::BASE_URL}/ips/#{ip}")
+        def get_ip(ip, &block)
+          resp = get(
+            @auth, SendGrid4r::REST::Ips::Addresses.url(ip), &block
+          )
           SendGrid4r::REST::Ips::Addresses.create_address(resp)
         end
 
-        def delete_ip_from_pool(pool_name, ip)
+        def delete_ip_from_pool(pool_name, ip, &block)
           delete(
             @auth,
-            "#{SendGrid4r::Client::BASE_URL}/ips/pools/#{pool_name}/ips/#{ip}"
+            SendGrid4r::REST::Ips::Pools.url(pool_name, 'ips', ip),
+            &block
           )
         end
       end

data/lib/sendgrid4r/rest/ips/pools.rb

@@ -17,45 +17,60 @@ module SendGrid4r
 
         Pool = Struct.new(:pool_name, :name, :ips)
 
+        def self.create_pools(resp)
+          return resp if resp.nil?
+          pools = []
+          resp.each do |pool|
+            pools.push(SendGrid4r::REST::Ips::Pools.create_pool(pool))
+          end
+          pools
+        end
+
         def self.create_pool(resp)
+          return resp if resp.nil?
           ips = []
           Array(resp['ips']).each { |ip| ips.push(ip) }
           Pool.new(resp['pool_name'], resp['name'], ips)
         end
 
-        def post_pool(name)
+        def self.url(name = nil, ips = nil, ip = nil)
+          url = "#{SendGrid4r::Client::BASE_URL}/ips/pools"
+          url = "#{url}/#{name}" unless name.nil?
+          url = "#{url}/#{ips}" unless ips.nil?
+          url = "#{url}/#{ip}" unless ip.nil?
+          url
+        end
+
+        def post_pool(name, &block)
           resp = post(
-            @auth, "#{SendGrid4r::Client::BASE_URL}/ips/pools", name: name
+            @auth, SendGrid4r::REST::Ips::Pools.url, name: name, &block
           )
           SendGrid4r::REST::Ips::Pools.create_pool(resp)
         end
 
-        def get_pools
-          resp_a = get(@auth, "#{SendGrid4r::Client::BASE_URL}/ips/pools")
-          pools = []
-          resp_a.each do |resp|
-            pools.push(SendGrid4r::REST::Ips::Pools.create_pool(resp))
-          end
-          pools
+        def get_pools(&block)
+          resp = get(@auth, SendGrid4r::REST::Ips::Pools.url, &block)
+          SendGrid4r::REST::Ips::Pools.create_pools(resp)
         end
 
-        def get_pool(name)
+        def get_pool(name, &block)
           resp = get(
-            @auth, "#{SendGrid4r::Client::BASE_URL}/ips/pools/#{name}"
+            @auth, SendGrid4r::REST::Ips::Pools.url(name), &block
           )
           SendGrid4r::REST::Ips::Pools.create_pool(resp)
         end
 
-        def put_pool(name, new_name)
+        def put_pool(name, new_name, &block)
           resp = put(
             @auth,
-            "#{SendGrid4r::Client::BASE_URL}/ips/pools/#{name}",
-            name: new_name)
+            SendGrid4r::REST::Ips::Pools.url(name),
+            name: new_name,
+            &block)
           SendGrid4r::REST::Ips::Pools.create_pool(resp)
         end
 
-        def delete_pool(name)
-          delete(@auth, "#{SendGrid4r::Client::BASE_URL}/ips/pools/#{name}")
+        def delete_pool(name, &block)
+          delete(@auth, SendGrid4r::REST::Ips::Pools.url(name), &block)
         end
       end
     end

data/lib/sendgrid4r/rest/ips/warmup.rb

@@ -11,42 +11,61 @@ module SendGrid4r
       #
       module Warmup
         include SendGrid4r::REST::Request
-        WarmupIp = Struct.new(:ip, :start_date)
 
-        def self.create_warmup_ip(resp)
-          WarmupIp.new(resp['ip'], resp['start_date'])
-        end
+        WarmupIp = Struct.new(:ip, :start_date)
 
-        def get_warmup_ips
+        def self.create_warmup_ips(resp)
+          return resp if resp.nil?
           ips = []
-          resp_a = get(@auth, "#{SendGrid4r::Client::BASE_URL}/ips/warmup")
-          resp_a.each do |resp|
-            ips.push(SendGrid4r::REST::Ips::Warmup.create_warmup_ip(resp))
+          resp.each do |warmup_ip|
+            ips.push(SendGrid4r::REST::Ips::Warmup.create_warmup_ip(warmup_ip))
           end
           ips
         end
 
-        def get_warmup_ip(ip_address)
+        def self.create_warmup_ip(resp)
+          return resp if resp.nil?
+          WarmupIp.new(
+            resp['ip'],
+            resp['start_date'].nil? ? nil : Time.at(resp['start_date'])
+          )
+        end
+
+        def self.url(ip_address = nil)
+          url = "#{SendGrid4r::Client::BASE_URL}/ips/warmup"
+          url = "#{url}/#{ip_address}" unless ip_address.nil?
+          url
+        end
+
+        def get_warmup_ips(&block)
+          resp = get(@auth, SendGrid4r::REST::Ips::Warmup.url, &block)
+          SendGrid4r::REST::Ips::Warmup.create_warmup_ips(resp)
+        end
+
+        def get_warmup_ip(ip_address, &block)
           resp = get(
             @auth,
-            "#{SendGrid4r::Client::BASE_URL}/ips/warmup/#{ip_address}"
+            SendGrid4r::REST::Ips::Warmup.url(ip_address),
+            &block
           )
           SendGrid4r::REST::Ips::Warmup.create_warmup_ip(resp)
         end
 
-        def post_warmup_ip(ip_address)
+        def post_warmup_ip(ip_address, &block)
           resp = post(
             @auth,
-            "#{SendGrid4r::Client::BASE_URL}/ips/warmup",
-            ip: ip_address
+            SendGrid4r::REST::Ips::Warmup.url,
+            ip: ip_address,
+            &block
           )
           SendGrid4r::REST::Ips::Warmup.create_warmup_ip(resp)
         end
 
-        def delete_warmup_ip(ip_address)
+        def delete_warmup_ip(ip_address, &block)
           delete(
             @auth,
-            "#{SendGrid4r::Client::BASE_URL}/ips/warmup/#{ip_address}"
+            SendGrid4r::REST::Ips::Warmup.url(ip_address),
+            &block
           )
         end
       end

data/lib/sendgrid4r/rest/request.rb

@@ -11,35 +11,32 @@ module SendGrid4r
     # SendGrid Web API v3 Request
     #
     module Request
-      # TODO: handle ratelimit headers
-      def get(auth, endpoint, params = nil, payload = nil)
-        execute(:get, auth, endpoint, params, payload)
+      def get(auth, endpoint, params = nil, payload = nil, &block)
+        execute(:get, auth, endpoint, params, payload, &block)
       end
 
-      def post(auth, endpoint, payload = nil)
-        execute(:post, auth, endpoint, nil, payload)
+      def post(auth, endpoint, payload = nil, &block)
+        execute(:post, auth, endpoint, nil, payload, &block)
       end
 
-      def patch(auth, endpoint, payload)
-        execute(:patch, auth, endpoint, nil, payload)
+      def patch(auth, endpoint, payload, &block)
+        execute(:patch, auth, endpoint, nil, payload, &block)
       end
 
-      def put(auth, endpoint, payload)
-        execute(:put, auth, endpoint, nil, payload)
+      def put(auth, endpoint, payload, &block)
+        execute(:put, auth, endpoint, nil, payload, &block)
       end
 
-      def delete(auth, endpoint, payload = nil)
-        execute(:delete, auth, endpoint, nil, payload)
+      def delete(auth, endpoint, payload = nil, &block)
+        execute(:delete, auth, endpoint, nil, payload, &block)
       end
 
-      def execute(method, auth, endpoint, params, payload)
-        args = {}
-        args[:method] = method
-        args[:url] = process_url_params(endpoint, params)
-        args[:user] = auth.username
-        args[:password] = auth.password
-        args[:headers] = { content_type: :json }
-        args[:payload] = payload.to_json unless payload.nil?
+      def execute(method, auth, endpoint, params, payload, &block)
+        args = create_args(method, auth, endpoint, params, payload)
+        if block_given?
+          RestClient::Request.execute(args, &block)
+          return nil
+        end
         body = RestClient::Request.execute(args)
         if body.nil? || body.length < 2
           body
@@ -48,6 +45,23 @@ module SendGrid4r
         end
       end
 
+      def create_args(method, auth, endpoint, params, payload)
+        args = {}
+        args[:method] = method
+        args[:url] = process_url_params(endpoint, params)
+        headers = {}
+        headers[:content_type] = :json
+        if !auth.api_key.nil?
+          headers[:authorization] = "Bearer #{auth.api_key}"
+        else
+          args[:user] = auth.username
+          args[:password] = auth.password
+        end
+        args[:headers] = headers
+        args[:payload] = payload.to_json unless payload.nil?
+        args
+      end
+
       def process_url_params(endpoint, params)
         if params.nil? || params.empty?
           endpoint

data/lib/sendgrid4r/rest/settings/enforced_tls.rb

@@ -14,22 +14,29 @@ module SendGrid4r
         EnforcedTls = Struct.new(:require_tls, :require_valid_cert)
 
         def self.create_enforced_tls(resp)
+          return resp if resp.nil?
           EnforcedTls.new(resp['require_tls'], resp['require_valid_cert'])
         end
 
-        def get_enforced_tls
+        def self.url
+          "#{SendGrid4r::Client::BASE_URL}/user/settings/enforced_tls"
+        end
+
+        def get_enforced_tls(&block)
           resp = get(
             @auth,
-            "#{SendGrid4r::Client::BASE_URL}/user/settings/enforced_tls"
+            SendGrid4r::REST::Settings::EnforcedTls.url,
+            &block
           )
           SendGrid4r::REST::Settings::EnforcedTls.create_enforced_tls(resp)
         end
 
-        def patch_enforced_tls(params)
+        def patch_enforced_tls(params, &block)
           resp = patch(
             @auth,
-            "#{SendGrid4r::Client::BASE_URL}/user/settings/enforced_tls",
-            params.to_h
+            SendGrid4r::REST::Settings::EnforcedTls.url,
+            params.to_h,
+            &block
           )
           SendGrid4r::REST::Settings::EnforcedTls.create_enforced_tls(resp)
         end