sendgrid4r 1.8.1 → 1.10.0

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

@@ -1,97 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module SendGrid4r
-  module REST
-    module Contacts
-      #
-      # SendGrid Web API v3 Contacts - Segments
-      #
-      module Segments
-        include SendGrid4r::REST::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'].each do |condition|
-            conditions.push(
-              SendGrid4r::REST::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'].each do |segment|
-            segments.push(
-              SendGrid4r::REST::Contacts::Segments.create_segment(segment)
-            )
-          end
-          Segments.new(segments)
-        end
-
-        def post_segment(params:, &block)
-          endpoint = SendGrid4r::REST::Contacts::Segments.url
-          resp = post(@auth, endpoint, params.to_h, &block)
-          SendGrid4r::REST::Contacts::Segments.create_segment(resp)
-        end
-
-        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:, &block)
-          endpoint = SendGrid4r::REST::Contacts::Segments.url(segment_id)
-          resp = get(@auth, endpoint, &block)
-          SendGrid4r::REST::Contacts::Segments.create_segment(resp)
-        end
-
-        def patch_segment(segment_id:, params:, &block)
-          endpoint = SendGrid4r::REST::Contacts::Segments.url(segment_id)
-          resp = patch(@auth, endpoint, params, &block)
-          SendGrid4r::REST::Contacts::Segments.create_segment(resp)
-        end
-
-        def delete_segment(segment_id:, &block)
-          endpoint = SendGrid4r::REST::Contacts::Segments.url(segment_id)
-          delete(@auth, endpoint, &block)
-        end
-
-        def get_recipients_on_segment(segment_id:, &block)
-          url = SendGrid4r::REST::Contacts::Segments.url(segment_id)
-          resp = get(@auth, "#{url}/recipients", nil, &block)
-          SendGrid4r::REST::Contacts::Recipients.create_recipients(resp)
-        end
-      end
-    end
-  end
-end

data/lib/sendgrid4r/rest/email_activity/email_activity.rb

@@ -1,81 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module SendGrid4r
-  module REST
-    #
-    # SendGrid Web API v3 EmailActivity
-    #
-    module EmailActivity
-      include SendGrid4r::REST::Request
-
-      #
-      # SendGrid Web API v3 Stats - 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
-        url = "#{BASE_URL}/email_activity"
-        url
-      end
-
-      def self.create_activities(resp)
-        return resp if resp.nil?
-        activities = []
-        resp.each do |activity|
-          activities.push(
-            SendGrid4r::REST::EmailActivity.create_activity(activity)
-          )
-        end
-        activities
-      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, SendGrid4r::REST::EmailActivity.url, params, &block)
-        SendGrid4r::REST::EmailActivity.create_activities(resp)
-      end
-    end
-  end
-end

data/lib/sendgrid4r/rest/templates/templates.rb

@@ -1,69 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module SendGrid4r
-  module REST
-    #
-    # SendGrid Web API v3 Template Engine - Templates
-    #
-    module Templates
-      include SendGrid4r::REST::Request
-
-      Templates = Struct.new(:templates)
-      Template = Struct.new(:id, :name, :versions)
-
-      def self.url(temp_id = nil)
-        url = "#{BASE_URL}/templates"
-        url = "#{url}/#{temp_id}" unless temp_id.nil?
-        url
-      end
-
-      def self.create_templates(resp)
-        return resp if resp.nil?
-        tmps = []
-        resp['templates'].each do |template|
-          tmps.push(SendGrid4r::REST::Templates.create_template(template))
-        end
-        Templates.new(tmps)
-      end
-
-      def self.create_template(resp)
-        return resp if resp.nil?
-        vers = []
-        resp['versions'].each do |ver|
-          vers.push(SendGrid4r::REST::Templates::Versions.create_version(ver))
-        end
-        Template.new(resp['id'], resp['name'], vers)
-      end
-
-      def post_template(name:, &block)
-        endpoint = SendGrid4r::REST::Templates.url
-        resp = post(@auth, endpoint, name: name, &block)
-        SendGrid4r::REST::Templates.create_template(resp)
-      end
-
-      def get_templates(&block)
-        resp = get(@auth, SendGrid4r::REST::Templates.url, &block)
-        SendGrid4r::REST::Templates.create_templates(resp)
-      end
-
-      def get_template(template_id:, &block)
-        endpoint = SendGrid4r::REST::Templates.url(template_id)
-        resp = get(@auth, endpoint, &block)
-        SendGrid4r::REST::Templates.create_template(resp)
-      end
-
-      def patch_template(template_id:, name:, &block)
-        endpoint = SendGrid4r::REST::Templates.url(template_id)
-        payload = {}
-        payload['name'] = name
-        resp = patch(@auth, endpoint, name: name, &block)
-        SendGrid4r::REST::Templates.create_template(resp)
-      end
-
-      def delete_template(template_id:, &block)
-        endpoint = SendGrid4r::REST::Templates.url(template_id)
-        delete(@auth, endpoint, &block)
-      end
-    end
-  end
-end

data/lib/sendgrid4r/rest/templates/versions.rb

@@ -1,95 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module SendGrid4r
-  module REST
-    #
-    # SendGrid Web API v3 Template Engine - Templates
-    #
-    module Templates
-      #
-      # SendGrid Web API v3 Template Engine - Versions
-      #
-      module Versions
-        include SendGrid4r::REST::Request
-
-        Version = Struct.new(
-          :id, :user_id, :template_id, :active, :name, :html_content,
-          :plain_content, :subject, :updated_at)
-
-        def self.create_version(resp)
-          return resp if resp.nil?
-          Version.new(
-            resp['id'],
-            resp['user_id'],
-            resp['template_id'],
-            resp['active'],
-            resp['name'],
-            resp['html_content'],
-            resp['plain_content'],
-            resp['subject'],
-            resp['updated_at'])
-        end
-
-        def self.url(temp_id, ver_id = nil)
-          url = "#{BASE_URL}/templates/#{temp_id}/versions"
-          url = "#{url}/#{ver_id}" unless ver_id.nil?
-          url
-        end
-
-        def post_version(template_id:, version:, &block)
-          endpoint = SendGrid4r::REST::Templates::Versions.url(template_id)
-          resp = post(
-            @auth,
-            endpoint,
-            remove_uneditable_keys(version.to_h),
-            &block
-          )
-          SendGrid4r::REST::Templates::Versions.create_version(resp)
-        end
-
-        def activate_version(template_id:, version_id:, &block)
-          url = SendGrid4r::REST::Templates::Versions.url(
-            template_id, version_id
-          )
-          resp = post(@auth, "#{url}/activate", &block)
-          SendGrid4r::REST::Templates::Versions.create_version(resp)
-        end
-
-        def get_version(template_id:, version_id:, &block)
-          resp = get(
-            @auth,
-            SendGrid4r::REST::Templates::Versions.url(template_id, version_id),
-            &block
-          )
-          SendGrid4r::REST::Templates::Versions.create_version(resp)
-        end
-
-        def patch_version(template_id:, version_id:, version:, &block)
-          resp = patch(
-            @auth,
-            SendGrid4r::REST::Templates::Versions.url(template_id, version_id),
-            remove_uneditable_keys(version.to_h),
-            &block
-          )
-          SendGrid4r::REST::Templates::Versions.create_version(resp)
-        end
-
-        def delete_version(template_id:, version_id:, &block)
-          delete(
-            @auth,
-            SendGrid4r::REST::Templates::Versions.url(template_id, version_id),
-            &block
-          )
-        end
-
-        private
-
-        def remove_uneditable_keys(hash_value)
-          hash_value.delete(:id) if hash_value.key?(:id)
-          hash_value.delete(:template_id) if hash_value.key?(:template_id)
-          hash_value
-        end
-      end
-    end
-  end
-end

data/spec/rest/api_keys/api_keys_spec.rb

@@ -1,210 +0,0 @@
-# encoding: utf-8
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe SendGrid4r::REST::ApiKeys do
-  describe 'integration test', :it do
-    before do
-      begin
-        Dotenv.load
-        @client = SendGrid4r::Client.new(api_key: ENV['API_KEY'])
-        @name1 = 'api_key_name1'
-        @name2 = 'api_key_name2'
-        @name1e = 'api_key_name1_edit'
-
-        # celan up test env(lists)
-        api_keys = @client.get_api_keys
-        api_keys.result.each do |api_key|
-          @client.delete_api_key(
-            api_key_id: api_key.api_key_id
-          ) if api_key.name == @name1
-          @client.delete_api_key(
-            api_key_id: api_key.api_key_id
-          ) if api_key.name == @name2
-          @client.delete_api_key(
-            api_key_id: api_key.api_key_id
-          ) if api_key.name == @name1e
-        end
-
-        # post api_key
-        @api_key1 = @client.post_api_key(name: @name1, scopes: ['mail.send'])
-      rescue RestClient::ExceptionWithResponse => e
-        puts e.inspect
-        raise e
-      end
-    end
-
-    context 'without block call' do
-      it '#get_api_keys' do
-        begin
-          api_keys = @client.get_api_keys
-          expect(api_keys).to be_a(SendGrid4r::REST::ApiKeys::ApiKeys)
-          expect(api_keys.result).to be_a(Array)
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#post_api_key' do
-        begin
-          api_key2 = @client.post_api_key(name: @name2)
-          expect(api_key2).to be_a(SendGrid4r::REST::ApiKeys::ApiKey)
-          expect(api_key2.name).to eq(@name2)
-          expect(api_key2.api_key_id).to be_a(String)
-          expect(api_key2.api_key).to be_a(String)
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#post_api_key with scopes' do
-        begin
-          api_key2 = @client.post_api_key(name: @name2, scopes: ['mail.send'])
-          expect(api_key2).to be_a(SendGrid4r::REST::ApiKeys::ApiKey)
-          expect(api_key2.name).to eq(@name2)
-          expect(api_key2.api_key_id).to be_a(String)
-          expect(api_key2.api_key).to be_a(String)
-          expect(api_key2.scopes).to be_a(Array)
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#get_api_key' do
-        begin
-          api_key = @client.get_api_key(api_key_id: @api_key1.api_key_id)
-          expect(api_key).to be_a(SendGrid4r::REST::ApiKeys::ApiKey)
-          expect(api_key.api_key_id).to eq(@api_key1.api_key_id)
-          expect(api_key.name).to eq('api_key_name1')
-          expect(api_key.scopes).to be_a(Array)
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#delete_api_key' do
-        begin
-          @client.delete_api_key(api_key_id: @api_key1.api_key_id)
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#patch_api_key' do
-        begin
-          edit_api_key = @client.patch_api_key(
-            api_key_id: @api_key1.api_key_id, name: @name1e
-          )
-          expect(edit_api_key.api_key_id).to eq(@api_key1.api_key_id)
-          expect(edit_api_key.name).to eq(@name1e)
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-
-      it '#put_api_key' do
-        begin
-          edit_api_key = @client.put_api_key(
-            api_key_id: @api_key1.api_key_id,
-            name: @name1e,
-            scopes: ['mail.send']
-          )
-          expect(edit_api_key.api_key_id).to eq(@api_key1.api_key_id)
-          expect(edit_api_key.name).to eq(@name1e)
-          expect(edit_api_key.scopes).to eq(['mail.send'])
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-    end
-  end
-
-  describe 'unit test', :ut do
-    let(:client) do
-      SendGrid4r::Client.new(api_key: '')
-    end
-
-    let(:api_keys) do
-      JSON.parse(
-        '{'\
-          '"result": ['\
-            '{'\
-              '"name": "A New Hope",'\
-              '"api_key_id": "xxxxxxxx"'\
-            '}'\
-          ']'\
-        '}'
-      )
-    end
-
-    let(:api_key) do
-      JSON.parse(
-        '{'\
-          '"api_key": "SG.xxxxxxxx.yyyyyyyy",'\
-          '"api_key_id": "xxxxxxxx",'\
-          '"name": "My API Key",'\
-          '"scopes": ['\
-            '"mail.send",'\
-            '"alerts.create",'\
-            '"alerts.read"'\
-          ']'\
-        '}'
-      )
-    end
-
-    it '#get_api_keys' do
-      allow(client).to receive(:execute).and_return(api_keys)
-      actual = client.get_api_keys
-      expect(actual).to be_a(SendGrid4r::REST::ApiKeys::ApiKeys)
-    end
-
-    it '#post_api_key' do
-      allow(client).to receive(:execute).and_return(api_key)
-      actual = client.post_api_key(name: '')
-      expect(actual).to be_a(SendGrid4r::REST::ApiKeys::ApiKey)
-    end
-
-    it '#delete_api_key' do
-      allow(client).to receive(:execute).and_return('')
-      actual = client.delete_api_key(api_key_id: '')
-      expect(actual).to eq('')
-    end
-
-    it '#patch_api_key' do
-      allow(client).to receive(:execute).and_return(api_key)
-      actual = client.patch_api_key(api_key_id: '', name: '')
-      expect(actual).to be_a(SendGrid4r::REST::ApiKeys::ApiKey)
-    end
-
-    it '#put_api_key' do
-      allow(client).to receive(:execute).and_return(api_key)
-      actual = client.put_api_key(api_key_id: '', name: '', scopes: [])
-      expect(actual).to be_a(SendGrid4r::REST::ApiKeys::ApiKey)
-    end
-
-    it 'creates api_key instance' do
-      actual = SendGrid4r::REST::ApiKeys.create_api_key(api_key)
-      expect(actual).to be_a(SendGrid4r::REST::ApiKeys::ApiKey)
-      expect(actual.api_key).to eq('SG.xxxxxxxx.yyyyyyyy')
-      expect(actual.api_key_id).to eq('xxxxxxxx')
-      expect(actual.name).to eq('My API Key')
-      expect(actual.scopes).to eq(['mail.send', 'alerts.create', 'alerts.read'])
-    end
-
-    it 'creates api_keys instance' do
-      actual = SendGrid4r::REST::ApiKeys.create_api_keys(api_keys)
-      expect(actual).to be_a(SendGrid4r::REST::ApiKeys::ApiKeys)
-      expect(actual.result).to be_a(Array)
-      actual.result.each do |api_key|
-        expect(api_key.name).to eq('A New Hope')
-        expect(api_key.api_key_id).to eq('xxxxxxxx')
-      end
-    end
-  end
-end

data/spec/rest/api_keys/permissions_spec.rb

@@ -1,65 +0,0 @@
-# encoding: utf-8
-require File.dirname(__FILE__) + '/../../spec_helper'
-
-describe SendGrid4r::REST::ApiKeys::Permissions do
-  describe 'integration test', :it do
-    before do
-      Dotenv.load
-      @client = SendGrid4r::Client.new(api_key: ENV['API_KEY'])
-    end
-
-    context 'without block call' do
-      it '#get_permissions' do
-        begin
-          permissions = @client.get_permissions
-          expect(permissions).to be_a(
-            SendGrid4r::REST::ApiKeys::Permissions::Permissions
-          )
-          expect(permissions.scopes).to be_a(Array)
-        rescue RestClient::ExceptionWithResponse => e
-          puts e.inspect
-          raise e
-        end
-      end
-    end
-  end
-
-  describe 'unit test', :ut do
-    let(:client) do
-      SendGrid4r::Client.new(api_key: '')
-    end
-
-    let(:permissions) do
-      JSON.parse(
-        '{'\
-          '"scopes": ['\
-            '"alerts.create",'\
-            '"alerts.read",'\
-            '"alerts.update"'\
-          ']'\
-        '}'
-      )
-    end
-
-    it '#get_permissions' do
-      allow(client).to receive(:execute).and_return(permissions)
-      actual = client.get_permissions
-      expect(actual).to be_a(
-        SendGrid4r::REST::ApiKeys::Permissions::Permissions
-      )
-    end
-
-    it 'creates permissions instance' do
-      actual = SendGrid4r::REST::ApiKeys::Permissions.create_permissions(
-        permissions
-      )
-      expect(actual).to be_a(
-        SendGrid4r::REST::ApiKeys::Permissions::Permissions
-      )
-      expect(actual.scopes).to be_a(Array)
-      expect(actual.scopes[0]).to eq('alerts.create')
-      expect(actual.scopes[1]).to eq('alerts.read')
-      expect(actual.scopes[2]).to eq('alerts.update')
-    end
-  end
-end