rock_rms 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9d81db433d9edd22ba5fa2148c2b0a82ac7f1150
-  data.tar.gz: 6b4b51e866c128c254aad44755fe03170946fd3b
+  metadata.gz: c3bf2fbd0092ad9afa7bc274f05201848d886b5f
+  data.tar.gz: 10715556852bd2472671646798a50ab35c78dd54
 SHA512:
-  metadata.gz: 33ffe1335a1d8b40e2388d65d9fdab92419644dd7cbabe9c468873fc9322655c033e77db9f1b92dcaf76e74b97fc7d6ec74ec5f8d446358c41b7267138723afd
-  data.tar.gz: 1c37aa2af141e7ba2e2b68bfcb13c859a7bd5b83e172053f61a5d4e6a8948161631f4667925016d8de44895b6ea71e0fa69e693b726fae78888a38cae07f082b
+  metadata.gz: 96eda68c2764ce38ecab7e8efcda03c6558c279c12f728bc9a927223ceb60bc40ce0ec971086475ce51d770f54036b8c933eec78d8c7ac1a9643d118b19a5536
+  data.tar.gz: 2862be265f417d8a922a6c45c123d2d8c85cb4347be3d2f279bfc949a0af56c8a3df5c20a424227ddbb8895d404678491e1e857c5b5a048dac1e79d05bba4277

data/README.md

@@ -1,5 +1,3 @@
-⚠️  Code is highly subject to change. Consider this an alpha release.
-
 ### A Ruby wrapper for the Rock RMS API
 
 To get a general overview of Rock RMS: https://www.rockrms.com
@@ -12,7 +10,7 @@ I'm a big fan of Rock so if you have problems using the gem or would like to see
 Add this line to your application's Gemfile:
 ````ruby
   # in your Gemfile
-  gem 'rock_rms', '~> 1.0'
+  gem 'rock_rms', '~> 1.1'
 
   # then...
   bundle install

data/lib/rock_rms/client.rb

@@ -10,8 +10,11 @@ module RockRMS
     include RockRMS::Client::Batch
     include RockRMS::Client::Donation
     include RockRMS::Client::Fund
+    include RockRMS::Client::Group
+    include RockRMS::Client::GroupMember
     include RockRMS::Client::PaymentMethod
     include RockRMS::Client::Person
+    include RockRMS::Client::PhoneNumber
     include RockRMS::Client::RecurringDonation
     include RockRMS::Client::TransactionDetail
 

data/lib/rock_rms/error.rb

@@ -9,7 +9,7 @@ module FaradayMiddleware
     def on_complete(env)
       case env[:status]
       when ERROR_STATUSES
-        raise RockRMS::Error, "#{env.status}: #{env.body}"
+        raise RockRMS::Error, "#{env[:status]}: #{env[:body]}"
       end
     end
   end

data/lib/rock_rms/resources/group.rb

@@ -0,0 +1,35 @@
+module RockRMS
+  class Client
+    module Group
+      def list_groups(options = {})
+        RockRMS::Responses::Group.format(get(group_path, options))
+      end
+
+      def find_group(id)
+        RockRMS::Responses::Group.format(get(group_path(id)))
+      end
+
+      def list_groups_for_person(person_id, options = {})
+        opts = options.dup
+        opts['$filter'] = Array(opts['$filter'])
+          .push("Members/any(m: m/PersonId eq #{person_id})")
+          .join(' and ')
+        opts['$expand'] ||= 'Members'
+
+        list_groups(opts)
+      end
+
+      def list_families_for_person(person_id, options = {})
+        RockRMS::Responses::Group.format(
+          get("Groups/GetFamilies/#{person_id}", options)
+        )
+      end
+
+      private
+
+      def group_path(id = nil)
+        id ? "Groups/#{id}" : 'Groups'
+      end
+    end
+  end
+end

data/lib/rock_rms/resources/group_member.rb

@@ -0,0 +1,32 @@
+module RockRMS
+  class Client
+    module GroupMember
+      def create_group_member(group_id:,
+                              group_member_status:,
+                              group_role_id:,
+                              person_id:)
+        post(
+          group_member_path,
+          {
+            IsSystem: false,
+            GroupId: group_id,
+            GroupMemberStatus: group_member_status,
+            GroupRoleId: group_role_id,
+            PersonId: person_id
+          }
+        )
+      end
+
+      def delete_group_member(id)
+        delete(group_member_path(id))
+      end
+
+      private
+
+      def group_member_path(id = nil)
+        id ? "GroupMembers/#{id}" : 'GroupMembers'
+      end
+    end
+  end
+end
+

data/lib/rock_rms/resources/person.rb

@@ -3,22 +3,32 @@ module RockRMS
     module Person
       def list_people(options = {})
         res = get(people_path, options)
-        RockRMS::Person.format(res)
+        RockRMS::Responses::Person.format(res)
       end
 
       def find_person(id)
         res = get(people_path(id))
-        RockRMS::Person.format(res)
+        RockRMS::Responses::Person.format(res)
       end
 
       def find_person_by_email(email)
         res = get("People/GetByEmail/#{email}")
-        RockRMS::Person.format(res)
+        RockRMS::Responses::Person.format(res)
       end
 
-      def find_person_by_name(full_name)
-        res = get("People/Search?name=#{full_name}&includeHtml=false&includeDetails=true&includeBusinesses=false&includeDeceased=false")
-        RockRMS::Person.format(res)
+      NAME_SEARCH_DEFAULTS = {
+        includeHtml: false,
+        includeDetails: true,
+        includeBusinesses: false,
+        includeDeceased: false
+      }.freeze
+
+      def find_person_by_name(full_name, options = {})
+        priority = options.merge(name: full_name)
+
+        RockRMS::Responses::Person.format(
+          get('People/Search', NAME_SEARCH_DEFAULTS.merge(priority))
+        )
       end
 
       def create_person(first_name:, last_name:, email:)

data/lib/rock_rms/resources/phone_number.rb

@@ -0,0 +1,15 @@
+module RockRMS
+  class Client
+    module PhoneNumber
+      def list_phone_numbers(options = {})
+        RockRMS::Responses::PhoneNumber.format(get(phone_number_path, options))
+      end
+
+      private
+
+      def phone_number_path(id = nil)
+        id ? "PhoneNumbers/#{id}" : "PhoneNumbers"
+      end
+    end
+  end
+end

data/lib/rock_rms/responses/campus.rb

@@ -0,0 +1,34 @@
+module RockRMS
+  module Responses
+    class Campus
+      MAP = {
+        id: 'Id',
+        name: 'Name',
+        is_active: 'IsActive',
+        description: 'Description',
+        short_code: 'ShortCode',
+        url: 'Url',
+        location_id: 'LocationId',
+        phone_number: 'PhoneNumber',
+        service_times: 'ServiceTimes',
+        guid: 'Guid'
+      }.freeze
+
+      def self.format(data)
+        if data.is_a?(Array)
+          data.map { |object| format_single(object) }
+        else
+          format_single(data)
+        end
+      end
+
+      private
+
+      def self.format_single(data)
+        MAP.each.with_object({}) do |(l,r), object|
+          object[l] = data[r]
+        end
+      end
+    end
+  end
+end

data/lib/rock_rms/responses/group.rb

@@ -0,0 +1,42 @@
+module RockRMS
+  module Responses
+    class Group
+      MAP = {
+        id: "Id",
+        name: "Name",
+        group_type_id: "GroupTypeId",
+        parent_group_id: "ParentGroupId",
+        campus_id: "CampusId",
+        is_active: "IsActive",
+        guid: "Guid",
+        members: "Members"
+      }.freeze
+
+      def self.format(data)
+        if data.is_a?(Array)
+          data.map { |object| format_single(object) }
+        else
+          format_single(data)
+        end
+      end
+
+      private
+
+      def self.format_single(data)
+        result = MAP.each.with_object({}) do |(l,r), object|
+          object[l] = data[r]
+        end
+
+        if group_locations = data['GroupLocations']
+          result[:group_locations] = GroupLocation.format(group_locations)
+        end
+
+        if campus = data['Campus']
+          result[:campus] = Campus.format(campus)
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/rock_rms/responses/group_location.rb

@@ -0,0 +1,34 @@
+module RockRMS
+  module Responses
+    class GroupLocation
+      MAP = {
+        id: 'Id',
+        group_id: 'GroupId',
+        location_id: 'LocationId',
+        guid: 'Guid'
+      }.freeze
+
+      def self.format(data)
+        if data.is_a?(Array)
+          data.map { |object| format_single(object) }
+        else
+          format_single(data)
+        end
+      end
+
+      private
+
+      def self.format_single(data)
+        result = MAP.each.with_object({}) do |(l,r), object|
+          object[l] = data[r]
+        end
+
+        if location = data['Location']
+          result[:location] = Location.format(location)
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/rock_rms/responses/location.rb

@@ -0,0 +1,37 @@
+module RockRMS
+  module Responses
+    class Location
+      MAP = {
+        id: 'Id',
+        name: 'Name',
+        is_active: 'IsActive',
+        street1: 'Street1',
+        street2: 'Street2',
+        city: 'City',
+        county: 'County',
+        state: 'State',
+        country: 'Country',
+        postal_code: 'PostalCode',
+        latitude: 'Latitude',
+        longitude: 'Longitude',
+        guid: 'Guid'
+      }.freeze
+
+      def self.format(data)
+        if data.is_a?(Array)
+          data.map { |object| format_single(object) }
+        else
+          format_single(data)
+        end
+      end
+
+      private
+
+      def self.format_single(data)
+        MAP.each.with_object({}) do |(l,r), object|
+          object[l] = data[r]
+        end
+      end
+    end
+  end
+end

data/lib/rock_rms/responses/person.rb

@@ -1,23 +1,35 @@
 module RockRMS
-  class Person
-    def self.format(response)
-      if response.is_a?(Array)
-        response.map { |person| format_person(person) }
-      else
-        format_person(response)
+  module Responses
+    class Person
+      MAP = {
+        id:         'Id',
+        name:       'FullName',
+        email:      'Email',
+        first_name: 'FirstName',
+        last_name:  'LastName',
+        giving_id:  'GivingId',
+        alias_id:   'PrimaryAliasId',
+        connection_status_value_id: 'ConnectionStatusValueId'
+      }.freeze
+
+      def self.format(data)
+        if data.is_a?(Array)
+          data.map { |object| format_single(object) }
+        else
+          format_single(data)
+        end
       end
-    end
 
-    def self.format_person(person)
-      {
-        id:         person['Id'],
-        name:       person['FullName'],
-        email:      person['Email'],
-        first_name: person['FirstName'],
-        last_name:  person['LastName'],
-        giving_id:  person['GivingId'],
-        alias_id:   person['PrimaryAliasId']
-      }
+      private
+
+      def self.format_single(data)
+        MAP.each.with_object({}) do |(l,r), object|
+          object[l] = data[r]
+        end
+      end
     end
   end
+
+  # for backwards compatibility
+  Person = Responses::Person
 end

data/lib/rock_rms/responses/phone_number.rb

@@ -0,0 +1,27 @@
+module RockRMS
+  module Responses
+    class PhoneNumber
+      MAP = {
+        id: 'Id',
+        person_id: 'PersonId',
+        number: 'Number',
+        formatted: 'NumberFormatted',
+        formatted_with_cc: 'NumberFormattedWithCountryCode'
+      }.freeze
+
+      def self.format(response)
+        if response.is_a?(Array)
+          response.map { |number| format_number(number) }
+        else
+          format_number(response)
+        end
+      end
+
+      def self.format_number(data)
+        MAP.each.with_object({}) do |(l,r), object|
+          object[l] = data[r]
+        end
+      end
+    end
+  end
+end

data/lib/rock_rms/version.rb

@@ -1,3 +1,3 @@
 module RockRMS
-  VERSION = '1.0.1'.freeze
+  VERSION = '1.1.0'.freeze
 end

data/spec/rock_rms/client_spec.rb

@@ -117,15 +117,15 @@ RSpec.describe RockRMS::Client do
     include_examples 'param request', :delete
   end
 
-  describe '#patch(path, req_body)' do
+  describe '#patch(path, options = {})' do
     include_examples 'body request', :patch
   end
 
-  describe '#post(path, req_body)' do
+  describe '#post(path, options = {})' do
     include_examples 'body request', :post
   end
 
-  describe '#put(path, req_body)' do
+  describe '#put(path, options = {})' do
     include_examples 'body request', :put
   end
 end

data/spec/rock_rms/resources/group_member_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+RSpec.describe RockRMS::Client::GroupMember, type: :model do
+  include_context 'resource specs'
+
+  describe '#create_group_member' do
+    context 'arguments' do
+      it 'require `group_id`' do
+        expect { client.create_group_member }
+          .to raise_error(ArgumentError, /group_id/)
+      end
+
+      it 'require `group_member_status`' do
+        expect { client.create_group_member }
+          .to raise_error(ArgumentError, /group_member_status/)
+      end
+
+      it 'require `group_role_id`' do
+        expect { client.create_group_member }
+          .to raise_error(ArgumentError, /group_role_id/)
+      end
+
+      it 'require `person_id`' do
+        expect { client.create_group_member }
+          .to raise_error(ArgumentError, /person_id/)
+      end
+
+    end
+
+    subject(:resource) {
+      client.create_group_member(
+        group_id: 123,
+        group_member_status: 1,
+        group_role_id: 456,
+        person_id: 123456
+      )
+    }
+
+    it 'returns integer' do
+      expect(resource).to be_a(Integer)
+    end
+
+    it 'passes options' do
+      expect(client).to receive(:post)
+        .with('GroupMembers', {
+          IsSystem: false,
+          GroupId: 123,
+          GroupMemberStatus: 1,
+          GroupRoleId: 456,
+          PersonId: 123456
+        })
+        .and_call_original
+      resource
+    end
+  end
+
+  describe '#delete_group_member' do
+    it 'returns nothing' do
+      expect(client.delete_group_member(123)).to eq(nil)
+    end
+
+    it 'passes id' do
+      expect(client).to receive(:delete).with('GroupMembers/123')
+      client.delete_group_member(123)
+    end
+  end
+end

data/spec/rock_rms/resources/group_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+RSpec.describe RockRMS::Client::Group, type: :model do
+  include_context 'resource specs'
+
+  describe '#find_group(id)' do
+    it 'returns a hash' do
+      expect(client.find_group(123)).to be_a(Hash)
+    end
+
+    it 'queries groups' do
+      expect(client).to receive(:get).with('Groups/123')
+        .and_call_original
+
+      resource = client.find_group(123)
+
+      expect(resource[:id]).to eq(112233)
+    end
+
+    it 'formats with Group' do
+      response = double
+      expect(RockRMS::Responses::Group).to receive(:format).with(response)
+      allow(client).to receive(:get).and_return(response)
+      client.find_group(123)
+    end
+  end
+
+  describe '#list_groups(options = {})' do
+    it 'returns a array of hashes' do
+      resource = client.list_groups
+      expect(resource).to be_a(Array)
+      expect(resource.first).to be_a(Hash)
+    end
+
+    it 'queries groups' do
+      expect(client).to receive(:get).with('Groups', {})
+        .and_call_original
+      client.list_groups
+    end
+
+    it 'passes options' do
+      expect(client).to receive(:get)
+        .with('Groups', { option1: '1' })
+        .and_return([])
+      client.list_groups(option1: '1')
+    end
+
+    it 'formats with Group' do
+      response = double
+      expect(RockRMS::Responses::Group).to receive(:format).with(response)
+      allow(client).to receive(:get).and_return(response)
+      client.list_groups
+    end
+  end
+
+  describe '#list_groups_for_person' do
+    it 'delegates to `list_groups`' do
+      expect(client).to receive(:list_groups)
+      client.list_groups_for_person(123)
+    end
+
+    it 'filters members by person_id' do
+      expect(client).to receive(:list_groups).with(
+        hash_including('$filter' => 'Members/any(m: m/PersonId eq 123)')
+      )
+      client.list_groups_for_person(123)
+    end
+
+    it 'expands member data by default' do
+      expect(client).to receive(:list_groups).with(
+        hash_including('$expand' => 'Members')
+      )
+      client.list_groups_for_person(123)
+    end
+
+    it 'supports passing additional filters' do
+      expect(client).to receive(:list_groups).with(
+        hash_including('$filter' => /GroupTypeId eq 45 and /)
+      )
+      client.list_groups_for_person(123, '$filter' => 'GroupTypeId eq 45')
+    end
+  end
+
+  describe '#list_families_for_person' do
+    it 'returns a array of hashes' do
+      resource = client.list_families_for_person(123)
+      expect(resource).to be_a(Array)
+      expect(resource.first).to be_a(Hash)
+    end
+
+    it 'queries families scoped to person' do
+      expect(client).to receive(:get).with('Groups/GetFamilies/123', {})
+        .and_call_original
+      client.list_families_for_person(123)
+    end
+
+    it 'passes options' do
+      expect(client).to receive(:get)
+        .with('Groups/GetFamilies/123', { option1: '1' })
+        .and_return([])
+      client.list_families_for_person(123, option1: '1')
+    end
+
+    it 'formats with Group' do
+      response = double
+      allow(client).to receive(:get).and_return(response)
+      expect(RockRMS::Responses::Group).to receive(:format).with(response)
+      client.list_families_for_person(123)
+    end
+  end
+end

data/spec/rock_rms/resources/person_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+RSpec.describe RockRMS::Client::Person, type: :model do
+  include_context 'resource specs'
+
+  describe '#find_person_by_name(full_name)' do
+    it 'returns a array of hashes' do
+      resource = client.find_person_by_name('Some Name')
+      expect(resource).to be_a(Array)
+      expect(resource.first).to be_a(Hash)
+    end
+
+    it 'queries people by name' do
+      expect(client).to receive(:get)
+        .with('People/Search', hash_including(name: 'Some Name'))
+        .and_call_original
+      client.find_person_by_name('Some Name')
+    end
+
+    it 'includes default options' do
+      expect(client).to receive(:get)
+        .with(
+          'People/Search',
+          hash_including(**described_class::NAME_SEARCH_DEFAULTS)
+        ).and_call_original
+      client.find_person_by_name('Some Name')
+    end
+
+    it 'passes options' do
+      expect(client).to receive(:get)
+        .with('People/Search', hash_including(option1: '1'))
+        .and_call_original
+      client.find_person_by_name('Some Name', option1: '1')
+    end
+
+    it 'overrides default options' do
+      expect(client).to receive(:get)
+        .with('People/Search', hash_including(includeHtml: true))
+        .and_call_original
+      client.find_person_by_name('Some Name', includeHtml: true)
+    end
+
+    it 'formats with Person' do
+      response = double
+      expect(RockRMS::Responses::Person).to receive(:format).with(response)
+      allow(client).to receive(:get).and_return(response)
+      client.find_person_by_name('Some Name')
+    end
+  end
+end