stbaldricks 1.5.1.pre

data/lib/stbaldricks/entities/communicate.rb

@@ -0,0 +1,20 @@
+require 'stbaldricks/endpoints/communicate'
+require 'stbaldricks/entities/lib/base'
+require 'stbaldricks/entities/message'
+require 'stbaldricks/entities/contact'
+
+module SBF
+  module Client
+    class Communicate < SBF::Client::Message
+      endpoint SBF::Client::CommunicateEndpoint
+
+      action :categories
+      action :years
+      action :groups
+      instance_action :compose
+      action :contacts
+
+      entity_collection_attr_accessor :to, 'SBF::Client::Contact'
+    end
+  end
+end

data/lib/stbaldricks/entities/config.rb

@@ -0,0 +1,41 @@
+require 'singleton'
+require 'stbaldricks/endpoints/config'
+require 'stbaldricks/entities/lib/top_level'
+
+module SBF
+  module Client
+    class Config < SBF::Client::TopLevelEntity
+      include Singleton
+      endpoint SBF::Client::ConfigEndpoint
+
+      action :get
+      instance_action :reload
+
+      attr_reader :open_registration_years
+      attr_reader :default_year
+      attr_reader :years_for_squire
+      attr_reader :years_for_knight
+      attr_reader :years_for_knight_commander
+      attr_reader :years_for_crusader
+      attr_reader :braintree_client_encryption_key
+      attr_reader :website_url
+      #NOTE: If you add another attribute, be sure to mock it out in `configure :test` of app.rb
+
+      # Attempts to call the method on the cached configuration object
+      def self.method_missing(method_name, *arguments, &block)
+        # The first time a missing method is called, call reload to make sure the instance has been populated
+        unless @_loaded
+          @_loaded = true
+          reload
+        end
+
+        # If the method being called exists on the instance, call it. Otherwise forward the request on to 'super'.
+        if instance.respond_to?(method_name)
+          return instance.send(method_name)
+        else
+          super(method_name, *arguments, &block)
+        end
+      end
+    end
+  end
+end

data/lib/stbaldricks/entities/contact.rb

@@ -0,0 +1,40 @@
+require 'stbaldricks/endpoints/contact'
+require 'stbaldricks/entities/lib/top_level'
+require 'stbaldricks/entities/person'
+require 'stbaldricks/entities/contact_group'
+require 'htmlentities'
+
+module SBF
+  module Client
+    class Contact < SBF::Client::TopLevelEntity
+      endpoint SBF::Client::ContactEndpoint
+
+      actions DEFAULT_CRUD_ACTIONS
+
+      module Type
+        WEBSITE = 'website'
+      end
+
+      attr_reader :id
+      entity_attr_accessor :owner, 'SBF::Client::FullPerson', 'SBF::Client::PartialPerson'
+      entity_attr_accessor :person, 'SBF::Client::FullPerson', 'SBF::Client::PartialPerson'
+      attr_accessor :type
+      attr_reader :display_name
+      attr_reader :email
+      attr_reader :created_at, :modified_at
+      entity_collection_attr_reader :contact_groups, 'SBF::Client::ContactGroup'
+
+      def display_name
+        HTMLEntities.new.decode(@display_name)
+      end
+    end
+
+    class CustomContact < SBF::Client::Contact
+      endpoint SBF::Client::ContactEndpoint
+
+      attr_accessor :id
+      attr_accessor :display_name
+      attr_accessor :email
+    end
+  end
+end

data/lib/stbaldricks/entities/contact_group.rb

@@ -0,0 +1,29 @@
+require 'stbaldricks/entities/lib/top_level'
+require 'stbaldricks/entities/person'
+require 'stbaldricks/entities/contact'
+require 'htmlentities'
+
+module SBF
+  module Client
+    class ContactGroup < SBF::Client::TopLevelEntity
+      actions DEFAULT_CRUD_ACTIONS
+
+      attr_accessor :id
+      attr_accessor :display_name
+      entity_attr_accessor :owner, 'SBF::Client::FullPerson'
+      attr_accessor :contacts
+      multitype_collection_attr_accessor(
+        :contacts,
+        [
+          [->(v) { v.key?(:person) && !v[:person].empty? }, 'SBF::Client::Contact'],
+          [ELSE, 'SBF::Client::CustomContact']
+        ]
+      )
+      attr_reader :created_at, :modified_at
+
+      def display_name
+        HTMLEntities.new.decode(@display_name)
+      end
+    end
+  end
+end

data/lib/stbaldricks/entities/document_library.rb

@@ -0,0 +1,19 @@
+require 'stbaldricks/entities/lib/top_level'
+require 'stbaldricks/entities/document_library_category'
+
+module SBF
+  module Client
+    class DocumentLibrary < SBF::Client::TopLevelEntity
+      actions DEFAULT_CRUD_ACTIONS
+
+      attr_accessor :id
+      attr_accessor :type
+      attr_accessor :title
+      attr_accessor :description
+      attr_accessor :url
+      attr_accessor :media_storage_id
+      attr_accessor :sort_order
+      entity_attr_reader :category, 'SBF::Client::DocumentLibraryCategory', nil, true
+    end
+  end
+end

data/lib/stbaldricks/entities/document_library_category.rb

@@ -0,0 +1,14 @@
+require 'stbaldricks/entities/lib/top_level'
+
+module SBF
+  module Client
+    class DocumentLibraryCategory < SBF::Client::TopLevelEntity
+      actions DEFAULT_CRUD_ACTIONS
+
+      attr_accessor :id
+      attr_accessor :top_level_category
+      attr_accessor :name
+      attr_accessor :sort_order
+    end
+  end
+end

data/lib/stbaldricks/entities/donation.rb

@@ -0,0 +1,372 @@
+require 'stbaldricks/entities/fund'
+require 'stbaldricks/entities/event'
+require 'stbaldricks/entities/team'
+require 'stbaldricks/entities/participant'
+require 'stbaldricks/entities/fundraiser'
+require 'stbaldricks/entities/person'
+require 'stbaldricks/entities/organization'
+require 'stbaldricks/entities/memorial'
+require 'stbaldricks/entities/lib/address'
+require 'stbaldricks/entities/lib/top_level'
+require 'stbaldricks/entities/lib/name'
+require 'stbaldricks/entities/lib/payment'
+require 'stbaldricks/entities/lib/default_cacheable'
+
+module SBF
+  module Client
+    class Donation < SBF::Client::TopLevelEntity
+      include Entities::DefaultCacheable
+      actions DEFAULT_CRUD_ACTIONS
+
+      disallow_instantiation
+
+      class EmployerMatching < SBF::Client::BaseEntity
+        attr_accessor :is_match, :employer, :matched_donation_id
+
+        def matched_donation_id=(value)
+          @matched_donation_id = value.to_i
+        end
+      end
+
+      class Tribute < SBF::Client::BaseEntity
+        attr_accessor :type
+        attr_reader :name
+        entity_attr_accessor :name_pieces, 'SBF::Client::NamePieces'
+
+        module Type
+          HONOR = 'honor'
+          TRIBUTE = 'tribute'
+        end
+      end
+
+      class FullParticipant < SBF::Client::FullParticipant
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::Donation::RecipientType::PARTICIPANT
+        end
+      end
+
+      class PartialParticipant < SBF::Client::PartialParticipant
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::Donation::RecipientType::PARTICIPANT
+        end
+      end
+
+      class FullFundraiser < SBF::Client::FullFundraiser
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::Donation::RecipientType::FUNDRAISER
+        end
+      end
+
+      class PartialFundraiser < SBF::Client::PartialFundraiser
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::Donation::RecipientType::FUNDRAISER
+        end
+      end
+
+      class FullTeam < SBF::Client::FullTeam
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::Donation::RecipientType::TEAM
+        end
+      end
+
+      class PartialTeam < SBF::Client::PartialTeam
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::Donation::RecipientType::TEAM
+        end
+      end
+
+      class FullEvent < SBF::Client::FullEvent
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::Donation::RecipientType::EVENT
+        end
+      end
+
+      class PartialEvent < SBF::Client::PartialEvent
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::Donation::RecipientType::EVENT
+        end
+      end
+
+      class FullFund < SBF::Client::FullFund
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::Donation::RecipientType::FUND
+        end
+      end
+
+      class PartialFund < SBF::Client::PartialFund
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::Donation::RecipientType::FUND
+        end
+      end
+
+      class FullMemorial < SBF::Client::FullMemorial
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::Donation::RecipientType::MEMORIAL
+        end
+      end
+
+      class PartialMemorial < SBF::Client::PartialMemorial
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::Donation::RecipientType::MEMORIAL
+        end
+      end
+
+      class SBFGeneralFund < SBF::Client::BaseEntity
+        attr_reader :model_type
+
+        def id
+          nil
+        end
+
+        def model_type
+          SBF::Client::Donation::RecipientType::SBF_GENERAL_FUND
+        end
+      end
+
+      class RecognitionCard < SBF::Client::BaseEntity
+        class Recipient < SBF::Client::BaseEntity
+          attr_reader :name
+          entity_attr_accessor :name_pieces, SBF::Client::NamePieces
+          entity_attr_accessor :address, SBF::Client::Address
+        end
+
+        entity_attr_accessor :recipient, SBF::Client::Donation::RecognitionCard::Recipient
+        attr_accessor :salutation, :message, :signature
+      end
+
+      def self.generate_special_donation_type(entity)
+        return if entity.nil?
+
+        # Calculate the country and state
+        country, state = get_country_and_state_for_special_donation_type(entity)
+
+        # state only applicable for United States, others only use international value
+        unless country.empty?
+          if country.to_sym == SBF::Client::Country.list[SBF::Client::Country::UNITED_STATES]
+            state_value = state.to_s.upcase.to_sym
+            if !state_value.empty? && SBF::Client::Donation::SpecialDonationType.const_defined?(state_value)
+              return SBF::Client::Donation::SpecialDonationType.const_get(state_value)
+
+            else
+              return SBF::Client::Donation::SpecialDonationType::NO_STATE
+            end
+
+          else
+            international_value = "INT_#{country}".upcase.to_sym
+            if SBF::Client::Donation::SpecialDonationType.const_defined?(international_value)
+              return SBF::Client::Donation::SpecialDonationType.const_get(international_value)
+
+            else
+              return SBF::Client::Donation::SpecialDonationType::INTERNATIONAL
+
+            end
+          end
+        end
+
+        SBF::Client::Donation::SpecialDonationType::GENERAL_EVENT
+      end
+
+      def self.get_country_and_state_for_special_donation_type(entity)
+        case entity
+        when SBF::Client::Search::Participant, SBF::Client::Search::Fundraiser, SBF::Client::Search::Team, SBF::Client::Search::Event
+          if entity.event_id == 1
+            # Look up the person since it is a Search::Participant and doesn't have sub-objects
+            response = SBF::Client::Person.get(entity.profile_id)
+            person = response.data
+            raise SBF::Client::Error, 'Invalid Entity' if response.error? || person.nil?
+
+            # Get country and state from the person
+            country = person.addresses.primary.country
+            state = (country.to_sym == SBF::Client::Country.list[SBF::Client::Country::UNITED_STATES] ? person.addresses.primary.state : '')
+
+          else
+            country = (defined?(entity.country).nil? ? nil : entity.country)
+            state = (defined?(entity.state).nil? ? nil : entity.state)
+
+          end
+
+          return [country, state]
+
+        when SBF::Client::Participant
+          return get_event_country_and_state_for_special_donation_type(entity.event, entity.person)
+
+        when SBF::Client::Fundraiser
+          return [entity.venue.location.address.country, entity.venue.location.address.state]
+
+        when SBF::Client::Team
+          return get_event_country_and_state_for_special_donation_type(entity.event)
+
+        when SBF::Client::Event
+          return get_event_country_and_state_for_special_donation_type(entity)
+
+        end
+      end
+      private_class_method :get_country_and_state_for_special_donation_type
+
+      def self.get_event_country_and_state_for_special_donation_type(event, person = nil)
+        if event.virtual?
+          raise SBF::Client::Error, 'Invalid Entity' if person.nil?
+
+          # Get country and state from the person
+          country = person.addresses.primary.country
+          state = (country.to_sym == SBF::Client::Country.list[SBF::Client::Country::UNITED_STATES] ? person.addresses.primary.state : '')
+
+        else
+          country = (defined?(event.venue.location.address.country).nil? ? nil : event.venue.location.address.country)
+          state = (defined?(event.venue.location.address.state).nil? ? nil : event.venue.location.address.state)
+
+        end
+
+        [country, state]
+      end
+      private_class_method :get_event_country_and_state_for_special_donation_type
+    end
+
+    class PartialDonation < SBF::Client::Donation
+      attr_accessor :id
+    end
+
+    class FullDonation < SBF::Client::Donation
+      attr_accessor :id
+      attr_accessor :status
+      attr_accessor :amount
+      attr_accessor :display_name
+      multitype_attr_accessor(
+        :recipient,
+        [
+          [
+            ->(v) { v[:model_type] == SBF::Client::Donation::RecipientType::PARTICIPANT },
+            'SBF::Client::Donation::FullParticipant',
+            'SBF::Client::Donation::PartialParticipant'
+          ],
+          [
+            ->(v) { v[:model_type] == SBF::Client::Donation::RecipientType::FUNDRAISER },
+            'SBF::Client::Donation::FullFundraiser',
+            'SBF::Client::Donation::PartialFundraiser'
+          ],
+          [
+            ->(v) { v[:model_type] == SBF::Client::Donation::RecipientType::TEAM },
+            'SBF::Client::Donation::FullTeam',
+            'SBF::Client::Donation::PartialTeam'
+          ],
+          [
+            ->(v) { v[:model_type] == SBF::Client::Donation::RecipientType::EVENT },
+            'SBF::Client::Donation::FullEvent',
+            'SBF::Client::Donation::PartialEvent'
+          ],
+          [
+            ->(v) { v[:model_type] == SBF::Client::Donation::RecipientType::FUND },
+            'SBF::Client::Donation::FullFund',
+            'SBF::Client::Donation::PartialFund'
+          ],
+          [
+            ->(v) { v[:model_type] == SBF::Client::Donation::RecipientType::MEMORIAL },
+            'SBF::Client::Donation::FullMemorial',
+            'SBF::Client::Donation::PartialMemorial'
+          ],
+          [
+            ->(v) { v[:model_type] == SBF::Client::Donation::RecipientType::SBF_GENERAL_FUND },
+            'SBF::Client::Donation::SBFGeneralFund'
+          ]
+        ],
+        optional: true
+      )
+
+      attr_accessor :is_unrecognized, :special_donation_type
+      multitype_attr_accessor(
+        :donor,
+        [
+          [
+            ->(v) { v[:type] == SBF::Client::Donation::DonorType::INDIVIDUAL },
+            'SBF::Client::FullPerson',
+            'SBF::Client::PartialPerson'
+          ],
+          [
+            ->(v) { v[:type] == SBF::Client::Donation::DonorType::BUSINESS },
+            'SBF::Client::FullOrganization',
+            'SBF::Client::PartialOrganization'
+          ],
+          [
+            ->(v) { v[:type] == SBF::Client::Donation::DonorType::ORGANIZATION_FOUNDATION },
+            'SBF::Client::FullOrganization',
+            'SBF::Client::PartialOrganization'
+          ]
+        ],
+        optional: true
+      )
+
+      multitype_attr_accessor(
+        :submitter,
+        [
+          [
+            ->(v) { v[:type] == SBF::Client::Donation::DonorType::INDIVIDUAL },
+            'SBF::Client::FullPerson',
+            'SBF::Client::PartialPerson'
+          ],
+          [
+            ->(v) { v[:type] == SBF::Client::Donation::DonorType::BUSINESS },
+            'SBF::Client::FullOrganization',
+            'SBF::Client::PartialOrganization'
+          ],
+          [
+            ->(v) { v[:type] == SBF::Client::Donation::DonorType::ORGANIZATION_FOUNDATION },
+            'SBF::Client::FullOrganization',
+            'SBF::Client::PartialOrganization'
+          ]
+        ],
+        optional: true
+      )
+
+      entity_attr_accessor :employer_matching, 'SBF::Client::Donation::EmployerMatching'
+      attr_accessor :foreign_beneficiary_country
+      attr_accessor :promotional_code
+      entity_attr_accessor :recurring_gift, 'SBF::Client::FullRecurringGift'
+      multitype_attr_accessor(
+        :payment_details,
+        [
+          [->(v) { v[:type] == SBF::Client::Payment::Type::CREDIT_CARD }, 'SBF::Client::Payment::CreditCardDetails'],
+          [->(v) { v[:type] == SBF::Client::Payment::Type::CASH }, 'SBF::Client::Payment::CashDetails'],
+          [->(v) { v[:type] == SBF::Client::Payment::Type::CHECK }, 'SBF::Client::Payment::CheckDetails'],
+          [->(v) { v[:type] == SBF::Client::Payment::Type::MONEY_ORDER }, 'SBF::Client::Payment::MoneyOrderDetails'],
+          [->(v) { v[:type] == SBF::Client::Payment::Type::NONCE }, 'SBF::Client::Payment::NonceDetails'],
+          [->(v) { v[:type] == SBF::Client::Payment::Type::WIRE_TRANSFER }, 'SBF::Client::Payment::WireTransferDetails'],
+          [->(v) { v[:type] == SBF::Client::Payment::Type::RECURRING_GIFTS }, 'SBF::Client::Payment::BraintreeSubscriptionDetails'],
+          [->(v) { v[:type] == SBF::Client::Payment::Type::UNKNOWN }, 'SBF::Client::Payment::UnknownDetails']
+        ]
+      )
+      entity_attr_accessor :tribute, 'SBF::Client::Donation::Tribute'
+      entity_attr_accessor :recognition_card, 'SBF::Client::Donation::RecognitionCard'
+      attr_accessor :collected_at
+      attr_accessor :created_at, :modified_at, :modified_by, :how_created
+      attr_accessor :is_thanked
+
+      def amount=(value)
+        @amount = value.to_s.gsub(/[^0-9\.]/, '').to_f
+      end
+    end
+  end
+end