stbaldricks 1.5.1.pre

data/lib/stbaldricks/entities/international_partner.rb

@@ -0,0 +1,58 @@
+require 'stbaldricks/entities/lib/address'
+require 'stbaldricks/entities/lib/name'
+require 'stbaldricks/entities/lib/fundraising_page'
+require 'stbaldricks/entities/person'
+require 'stbaldricks/entities/lib/top_level'
+
+module SBF
+  module Client
+    class InternationalPartner < SBF::Client::TopLevelEntity
+      actions DEFAULT_CRUD_ACTIONS
+      blacklist_action :create
+      blacklist_action :update
+      blacklist_action :delete
+
+      disallow_instantiation
+
+      module Status
+        ACTIVE = 'active'
+        PENDING = 'pending'
+      end
+
+      class WebPage < SBF::Client::BaseEntity
+        attr_accessor :url
+        attr_accessor :custom_url_segment
+      end
+
+      class Link < SBF::Client::BaseEntity
+        attr_accessor :url
+        attr_accessor :text
+      end
+    end
+
+    class PartialInternationalPartner < SBF::Client::InternationalPartner
+      attr_accessor :id
+    end
+
+    class FullInternationalPartner < SBF::Client::InternationalPartner
+      attr_accessor :id
+      attr_accessor :status
+      attr_accessor :year
+      attr_accessor :country
+      attr_accessor :country_name
+      attr_accessor :name
+      attr_accessor :message
+      attr_accessor :description
+      entity_attr_accessor :web_page, 'SBF::Client::InternationalPartner::WebPage'
+      entity_attr_accessor :link, 'SBF::Client::InternationalPartner::Link'
+      attr_accessor :donate_url
+      attr_accessor :base_photo_url
+
+      attr_accessor :created_at
+
+      def active?
+        status == SBF::Client::InternationalPartner::Status::ACTIVE
+      end
+    end
+  end
+end

data/lib/stbaldricks/entities/kid.rb

@@ -0,0 +1,190 @@
+require 'stbaldricks/endpoints/kid'
+require 'stbaldricks/entities/lib/address'
+require 'stbaldricks/entities/lib/name'
+require 'stbaldricks/entities/lib/fundraising_page'
+require 'stbaldricks/entities/person'
+require 'stbaldricks/entities/lib/base'
+require 'stbaldricks/entities/lib/default_cacheable'
+
+module SBF
+  module Client
+    class Diagnosis < SBF::Client::BaseEntity
+      attr_accessor :date
+      attr_accessor :cancer_type
+      attr_accessor :other
+
+      module CancerType
+        ACUTE_LYMPHOBLASTIC_LEUKEMIA = 'acute_lymphoblastic_leukemia'
+        ACUTE_MYELOID_LEUKEMIA = 'acute_myeloid_leukemia'
+        BRAIN_OR_SPINAL_CORD_TUMOR = 'brain_or_spinal_cord_tumor'
+        KIDNEY_SARCOMA = 'kidney_sarcoma'
+        EWING_SARCOMA = 'ewing_sarcoma'
+        GERM_CELL_TUMOR = 'germ_cell_tumor'
+        HEPATOBLASTOMA = 'hepatoblastoma'
+        HODGKIN_LYMPHOMA = 'hodgkin_lymphoma'
+        LYMPHOMA = 'lymphoma'
+        NEUROBLASTOMA = 'neuroblastoma'
+        NON_HODGKIN_LYMPHOMA = 'non_hodgkin_lymphoma'
+        OSTEOSARCOMA = 'osteosarcoma'
+        RETINOBLASTOMA = 'retinoblastoma'
+        RHABDOMYOSARCOMA = 'rhabdomyosarcoma'
+        WILMS_OR_OTHER_KIDNEY_TUMOR = 'wilms_or_other_kidney_tumor'
+        ADULT_WITH_CHILDHOOD_CANCER = 'adult_with_childhood_cancer'
+        OTHER_CHILDHOOD_CANCER = 'other_childhood_cancer'
+      end
+    end
+
+    class Guardian < SBF::Client::BaseEntity
+      module RelationshipType
+        SELF_ADULT = 'adult'
+        SELF_MINOR = 'minor'
+        MOTHER = 'mother'
+        FATHER = 'father'
+        SISTER = 'sister'
+        BROTHER = 'brother'
+        AUNT = 'aunt'
+        UNCLE = 'uncle'
+        GRANDMOTHER = 'grandmother'
+        GRANDFATHER = 'grandfather'
+        STEP_MOTHER = 'stepmother'
+        STEP_FATHER = 'stepfather'
+        FRIEND = 'friend'
+        COUSIN = 'cousin'
+      end
+
+      attr_accessor :name
+      attr_accessor :relationship
+      entity_attr_accessor :name_pieces, 'SBF::Client::NamePieces'
+      entity_attr_accessor :email_address, 'SBF::Client::EmailAddress'
+      entity_attr_accessor :phone, 'SBF::Client::Phone'
+    end
+
+    class TreatmentStatus < SBF::Client::BaseEntity
+      attr_accessor :state
+      attr_accessor :other
+
+      module SurvivorState
+        IN_TREATMENT = 'in_treatment'
+        IN_MAINTENANCE = 'in_maintenance'
+        IN_REMISSION = 'in_remission'
+        NED = 'no_evidence_of_disease'
+        CANCER_FREE = 'cancer_free'
+        OTHER_LIVING = 'other_living'
+      end
+
+      module DeceasedState
+        ANGEL = 'angel'
+        DECEASED = 'deceased'
+        PASSED_AWAY = 'passed_away'
+        OTHER_DECEASED = 'other_deceased'
+      end
+    end
+
+    class KidURL < SBF::Client::BaseEntity
+      attr_accessor :url
+    end
+
+    class Photos < SBF::Client::BaseEntity
+      attr_reader :avatar, :default
+    end
+
+    class KidInstitution < SBF::Client::BaseEntity
+      attr_reader :id
+      attr_reader :display_name
+      attr_reader :city
+      attr_reader :state
+      attr_reader :zip_code
+      attr_reader :country
+      attr_reader :created_at
+      attr_reader :modified_at
+    end
+
+    class Kid < SBF::Client::TopLevelEntity
+      include Entities::DefaultCacheable
+      endpoint SBF::Client::KidEndpoint
+      actions DEFAULT_CRUD_ACTIONS
+      action :find_random
+      blacklist_action :create
+      blacklist_action :delete
+
+      disallow_instantiation
+
+      module Status
+        ACTIVE = 'active'
+        PENDING = 'pending'
+        SUSPENDED = 'suspended'
+      end
+
+      class Relationship < SBF::Client::BaseEntity
+        module Type
+          SELF_ADULT = 'adult'
+          SELF_MINOR = 'minor'
+          MOTHER = 'mother'
+          FATHER = 'father'
+          SISTER = 'sister'
+          BROTHER = 'brother'
+          AUNT = 'aunt'
+          UNCLE = 'uncle'
+          GRANDMOTHER = 'grandmother'
+          GRANDFATHER = 'grandfather'
+          STEP_MOTHER = 'stepmother'
+          STEP_FATHER = 'stepfather'
+          FRIEND = 'friend'
+          COUSIN = 'cousin'
+        end
+
+        module GuardianType
+          LEGAL_GUARDIAN = 'legal_guardian'
+          NONCUSTODIAL_GUARDIAN = 'non_custodial_guardian'
+          OTHER = 'other'
+        end
+
+        class Permissions < SBF::Client::BaseEntity
+          attr_accessor :is_editor
+        end
+
+        attr_accessor :kid_id
+        entity_attr_accessor :person, 'SBF::Client::FullPerson', 'SBF::Client::PartialPerson'
+        attr_accessor :type
+        attr_accessor :guardian_type
+        attr_accessor :is_submitter
+        entity_attr_accessor :permissions, 'SBF::Client::Kid::Relationship::Permissions'
+      end
+    end
+
+    class PartialKid < SBF::Client::Kid
+      attr_accessor :id
+    end
+
+    class FullKid < SBF::Client::Kid
+      attr_accessor :id
+      attr_accessor :status
+      attr_accessor :gender
+      attr_accessor :birthday
+      attr_accessor :ethnicity
+      attr_accessor :date_of_passing
+      attr_accessor :display_name
+      attr_accessor :display_name_override
+      attr_accessor :name
+      entity_attr_accessor :name_pieces, 'SBF::Client::NamePieces'
+      entity_attr_accessor :address, 'SBF::Client::Address'
+      entity_attr_accessor :diagnosis, 'SBF::Client::Diagnosis'
+      entity_attr_accessor :treatment_status, 'SBF::Client::TreatmentStatus'
+      attr_accessor :web_message
+      entity_attr_accessor :photos, 'SBF::Client::Photos'
+      entity_attr_accessor :web_page, 'SBF::Client::WebPage'
+      entity_attr_accessor :guardian, 'SBF::Client::Guardian'
+      entity_collection_attr_accessor :relationships, 'SBF::Client::Kid::Relationship'
+      entity_collection_attr_accessor :urls, 'SBF::Client::KidURL'
+      entity_collection_attr_reader :institutions, 'SBF::Client::KidInstitution'
+
+      attr_accessor :created_at
+      attr_accessor :modified_at
+      attr_accessor :modified_by
+
+      def active?
+        status == SBF::Client::Kid::Status::ACTIVE
+      end
+    end
+  end
+end

data/lib/stbaldricks/entities/kid_honor.rb

@@ -0,0 +1,123 @@
+require 'stbaldricks/endpoints/kid_honor'
+require 'stbaldricks/entities/kid'
+require 'stbaldricks/entities/event'
+require 'stbaldricks/entities/team'
+require 'stbaldricks/entities/participant'
+require 'stbaldricks/entities/fundraiser'
+require 'stbaldricks/entities/lib/top_level'
+
+module SBF
+  module Client
+    class KidHonor < SBF::Client::TopLevelEntity
+      endpoint SBF::Client::KidHonorEndpoint
+      actions DEFAULT_CRUD_ACTIONS
+      blacklist_action :get
+      blacklist_action :update
+
+      attr_accessor :honored_on
+      entity_attr_accessor :kid, 'SBF::Client::KidHonor::FullKid', 'SBF::Client::KidHonor::PartialKid'
+      multitype_attr_accessor(
+        :honorer,
+        [
+          [
+            ->(v) { v[:model_type] == SBF::Client::KidHonor::HonorerType::PARTICIPANT },
+            'SBF::Client::KidHonor::FullParticipant',
+            'SBF::Client::KidHonor::PartialParticipant'
+          ],
+          [
+            ->(v) { v[:model_type] == SBF::Client::KidHonor::HonorerType::FUNDRAISER },
+            'SBF::Client::KidHonor::FullFundraiser',
+            'SBF::Client::KidHonor::PartialFundraiser'
+          ],
+          [
+            ->(v) { v[:model_type] == SBF::Client::KidHonor::HonorerType::TEAM },
+            'SBF::Client::KidHonor::FullTeam',
+            'SBF::Client::KidHonor::PartialTeam'
+          ],
+          [
+            ->(v) { v[:model_type] == SBF::Client::KidHonor::HonorerType::EVENT },
+            'SBF::Client::KidHonor::FullEvent',
+            'SBF::Client::KidHonor::PartialEvent'
+          ]
+        ]
+      )
+
+      module HonorerType
+        EVENT = 'event'
+        TEAM = 'team'
+        PARTICIPANT = 'participant'
+        FUNDRAISER = 'fundraiser'
+      end
+
+      class PartialKid < SBF::Client::PartialKid
+      end
+
+      class FullKid < SBF::Client::FullKid
+      end
+
+      class FullParticipant < SBF::Client::FullParticipant
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::KidHonor::HonorerType::PARTICIPANT
+        end
+      end
+
+      class PartialParticipant < SBF::Client::PartialParticipant
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::KidHonor::HonorerType::PARTICIPANT
+        end
+      end
+
+      class FullFundraiser < SBF::Client::FullFundraiser
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::KidHonor::HonorerType::FUNDRAISER
+        end
+      end
+
+      class PartialFundraiser < SBF::Client::PartialFundraiser
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::KidHonor::HonorerType::FUNDRAISER
+        end
+      end
+
+      class FullTeam < SBF::Client::FullTeam
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::KidHonor::HonorerType::TEAM
+        end
+      end
+
+      class PartialTeam < SBF::Client::PartialTeam
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::KidHonor::HonorerType::TEAM
+        end
+      end
+
+      class FullEvent < SBF::Client::FullEvent
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::KidHonor::HonorerType::EVENT
+        end
+      end
+
+      class PartialEvent < SBF::Client::PartialEvent
+        attr_reader :model_type
+
+        def model_type
+          SBF::Client::KidHonor::HonorerType::EVENT
+        end
+      end
+    end
+  end
+end

data/lib/stbaldricks/entities/lib/address.rb

@@ -0,0 +1,25 @@
+require 'stbaldricks/entities/lib/base'
+
+module SBF
+  module Client
+    class Address < SBF::Client::BaseEntity
+      module Type
+        HOME = 'home'
+        BUSINESS = 'business'
+      end
+
+      attr_accessor :type
+      attr_accessor :business_name
+      attr_accessor :address1, :address2, :city, :state, :state_name, :zip, :country, :country_name
+      attr_accessor :latitude, :longitude
+
+      def city_state_zip
+        csz = ''
+        csz += @city + ', ' unless @city.nil?
+        csz += @state + ' ' unless @state.nil?
+        csz += @zip unless @zip.nil?
+        csz.strip
+      end
+    end
+  end
+end

data/lib/stbaldricks/entities/lib/base.rb

@@ -0,0 +1,505 @@
+# Require all monkey patches
+patch_dir = File.expand_path('../../../patches', __FILE__)
+Dir["#{patch_dir}/*.rb"].each { |file| require file }
+
+require 'set'
+require 'stbaldricks/client'
+require 'stbaldricks/entities/lib/error'
+require 'active_model'
+require 'securerandom'
+
+module SBF
+  module Client
+    class BaseEntity
+      extend ActiveModel::Naming
+      extend ActiveModel::Translation
+      include ActiveModel::Conversion
+
+      attr_reader :errors
+
+      ELSE = ->(_) { true }
+
+      # Class level instance variable to keep track of defined attributes
+      @attributes = nil
+      @optional_attributes = nil
+      @entity_attributes = nil
+      @not_provided_attributes = nil
+      @disallow_instantiation = nil
+
+      def initialize(data = {})
+        # If disallow instantiation has been set, raise an error if someone is trying to call initilaize
+        raise SBF::Client::Error, 'Initialize is not valid on a base object. Use the full or partial version' unless self.class.allow_instantiation?
+
+        super()
+
+        @errors = ActiveModel::Errors.new(self)
+        self.attributes = data
+      end
+
+      # Overridden from ActiveModel::Naming to remove namespace and Full/Partial
+      def model_name
+        @_model_name ||= ActiveModel::Name.new(self, SBF::Client, self.class.name.gsub(/::(Full|Partial)/, '::'))
+      end
+
+      def persisted?
+        true
+      end
+
+      def attributes=(data)
+        data ||= {}
+        data.each do |key, value|
+          # Use the setter if one is available, otherwise set the variable directly
+          setter = "#{key}=".to_sym
+          if respond_to?(setter, true)
+            send(setter, value)
+
+          else
+            instance_variable_set("@#{key}".to_sym, value)
+
+          end
+        end
+
+        # For each attribute that may be optional, call mark_attribute_not_provided
+        # if the data set does not contain a key with the optional attribute's name
+        self.class.optional_attributes.each { |name| mark_attribute_not_provided(name) unless data.key?(name) }
+      end
+
+      def add_errors(error)
+        errors.clear
+        count = error.fields.length
+        error.fields.each do |field|
+          field = field.gsub('_id', '') # Hacky, since API returns DB field that errored instead of View Field
+          errors.add(field, error.details) if count > 1
+          errors.add(:base, "#{field}: #{error.details}") if count == 1
+        end
+        errors.add(:base, "#{error.type}: #{error.details}") if count == 0
+      end
+
+      def mark_attribute_not_provided(name)
+        return if not_provided_attributes.include?(name)
+
+        # Put the method in the list of not_provided methods
+        not_provided_attributes << name
+
+        # Back up the original version of the setter method if it doesn't already exist
+        setter = setter_method_name(name)
+        setter_backup = setter_backup_method_name(name)
+        singleton_class.send(:alias_method, setter_backup, setter) unless respond_to?(setter_backup, true)
+
+        # Back up the original version of the getter method if it doesn't already exist
+        getter = getter_method_name(name)
+        getter_backup = getter_backup_method_name(name)
+        singleton_class.send(:alias_method, getter_backup, getter) unless respond_to?(getter_backup, true)
+
+        # If we set the value in a not_provided method, that means we now have requested the data and we
+        # should replace the original getter/setter and set the value using the original method
+        define_singleton_method(setter) { |v|
+          unmark_attribute_not_provided(name)
+          super(v)
+        }
+
+        # If we try to get the value in a not_provided method, we should raise an error
+        define_singleton_method(getter) {
+          raise(
+            SBF::Client::DataNotProvidedError,
+            "Data not provided for the #{name} attribute. This is usually due to the attribute not being requested in the 'with' declaration"
+          )
+        }
+      end
+      private :mark_attribute_not_provided
+
+      def unmark_attribute_not_provided(name)
+        return unless not_provided_attributes.include?(name)
+
+        # Remove the method from the list of not_provided methods
+        not_provided_attributes.delete(name)
+
+        # Replace the original version of the setter method using the backup
+        setter = setter_method_name(name)
+        setter_backup = setter_backup_method_name(name)
+        singleton_class.send(:alias_method, setter, setter_backup)
+
+        # Replace the original version of the getter method using the backup
+        getter = getter_method_name(name)
+        getter_backup = getter_backup_method_name(name)
+        singleton_class.send(:alias_method, getter, getter_backup)
+      end
+      private :unmark_attribute_not_provided
+
+      def setter_method_name(name)
+        "#{name}=".to_sym
+      end
+      private :setter_method_name
+
+      def getter_method_name(name)
+        name.to_sym
+      end
+      private :getter_method_name
+
+      def setter_backup_method_name(name)
+        "_#{name}=".to_sym
+      end
+      private :setter_backup_method_name
+
+      def getter_backup_method_name(name)
+        "_#{name}".to_sym
+      end
+      private :getter_backup_method_name
+
+      # So this method is meant to ensure that you don't do SBF::Client::Participant.new and are forced, instead,
+      # to be explicit about calling either SBF::Client::FullParticipant.new or SBF::Client::PartialParticipant.new
+      def self.disallow_instantiation
+        @disallow_instantiation = true
+      end
+      private_class_method :disallow_instantiation
+
+      # Class method which retrieves the
+      def self.allow_instantiation?
+        !@disallow_instantiation
+      end
+
+      # Class method to retrieve the not_provided_attributes attribute
+      def not_provided_attributes
+        @not_provided_attributes ||= Set.new
+      end
+
+      ###########################################################################################
+      # Override for the ruby built-in attribute accessors. Creates a list of attributes that can be
+      # accessed at will and adds some helper methods.
+      def self.attr_reader(*vars)
+        attributes.merge(vars)
+        super(*vars)
+        add_boolean_methods(vars)
+      end
+
+      def self.attr_writer(*vars)
+        attributes.merge(vars)
+        super(*vars)
+        add_boolean_methods(vars, true)
+      end
+
+      def self.attr_accessor(*vars)
+        attributes.merge(vars)
+        super(*vars)
+        add_boolean_methods(vars, true)
+      end
+      ###########################################################################################
+
+      ###########################################################################################
+      # Multitype Attribute accessors. These methods take an array of type to class mappings.
+      # Expected form is:
+      # [[<lamda method which evals to true if this type should be used>, <full class>, <partial class>], [...]]
+      def self.multitype_attr_reader(attribute, class_mappings, optional = false)
+        entity_attributes << attribute
+        optional_attributes << attribute if optional
+        attr_reader(attribute)
+        add_multitype_setter_method(attribute, class_mappings, true)
+      end
+
+      def self.multitype_attr_writer(attribute, class_mappings, optional = false)
+        entity_attributes << attribute
+        optional_attributes << attribute if optional
+        attr_writer(attribute)
+        add_multitype_setter_method(attribute, class_mappings)
+      end
+
+      def self.multitype_attr_accessor(attribute, class_mappings, optional = false)
+        entity_attributes << attribute
+        optional_attributes << attribute if optional
+        attr_accessor(attribute)
+        add_multitype_setter_method(attribute, class_mappings)
+      end
+      ###########################################################################################
+
+      ###########################################################################################
+      # Entity attr accessors are simpler to define/easier to read but they really just create a type mapping
+      # for the given inputs and then function the same as the multitype attribute accessors do.
+      def self.entity_attr_reader(attribute, full_class, partial_class = nil, optional = false)
+        mapping_for_single_class = [[ELSE, full_class, partial_class]]
+        multitype_attr_reader(attribute, mapping_for_single_class, optional)
+      end
+
+      def self.entity_attr_writer(attribute, full_class, partial_class = nil, optional = false)
+        mapping_for_single_class = [[ELSE, full_class, partial_class]]
+        multitype_attr_writer(attribute, mapping_for_single_class, optional)
+      end
+
+      def self.entity_attr_accessor(attribute, full_class, partial_class = nil, optional = false)
+        mapping_for_single_class = [[ELSE, full_class, partial_class]]
+        multitype_attr_accessor(attribute, mapping_for_single_class, optional)
+      end
+      ###########################################################################################
+
+      ###########################################################################################
+      # Multitype Collection accessors. These methods take an array of type to class mappings.
+      # Expected form is:
+      # [[<lamda method which evals to true if this type should be used>, <full class>, <partial class>], [...]]
+      def self.multitype_collection_attr_reader(attribute, class_mappings, optional = false)
+        collection_attributes << attribute
+        optional_attributes << attribute if optional
+        attr_reader(attribute)
+        add_multitype_collection_setter_method(attribute, class_mappings, true)
+      end
+
+      def self.multitype_collection_attr_writer(attribute, class_mappings, optional = false)
+        collection_attributes << attribute
+        optional_attributes << attribute if optional
+        attr_writer(attribute)
+        add_multitype_collection_setter_method(attribute, class_mappings)
+      end
+
+      def self.multitype_collection_attr_accessor(attribute, class_mappings, optional = false)
+        collection_attributes << attribute
+        optional_attributes << attribute if optional
+        attr_accessor(attribute)
+        add_multitype_collection_setter_method(attribute, class_mappings)
+      end
+      ###########################################################################################
+
+      ###########################################################################################
+      # Entity attr accessors are simpler to define/easier to read but they really just create a type mapping
+      # for the given inputs and then function the same as the multitype attribute accessors do.
+      def self.entity_collection_attr_reader(attribute, full_class, partial_class = nil, optional = false)
+        mapping_for_single_class = [[ELSE, full_class, partial_class]]
+        multitype_collection_attr_reader(attribute, mapping_for_single_class, optional)
+      end
+
+      def self.entity_collection_attr_writer(attribute, full_class, partial_class = nil, optional = false)
+        mapping_for_single_class = [[ELSE, full_class, partial_class]]
+        multitype_collection_attr_writer(attribute, mapping_for_single_class, optional)
+      end
+
+      def self.entity_collection_attr_accessor(attribute, full_class, partial_class = nil, optional = false)
+        mapping_for_single_class = [[ELSE, full_class, partial_class]]
+        multitype_collection_attr_accessor(attribute, mapping_for_single_class, optional)
+      end
+      ###########################################################################################
+
+      def self.attributes
+        @attributes ||= Set.new
+      end
+
+      def self.optional_attributes
+        @optional_attributes ||= Set.new
+      end
+
+      def self.entity_attributes
+        @entity_attributes ||= Set.new
+      end
+
+      def self.collection_attributes
+        @collection_attributes ||= Set.new
+      end
+
+      def self.add_boolean_methods(vars, setter = false)
+        vars.each do |attribute|
+          split_attribute = attribute.to_s.split('is_')
+          next if split_attribute.length <= 1
+          define_method(:"#{split_attribute.last}?") { send(attribute) }
+          define_method(:"#{attribute}=") { |val| instance_variable_set("@#{attribute}".to_sym, val.to_s.to_b) } if setter
+        end
+      end
+      private_class_method :add_boolean_methods
+
+      # Creates a private method which resolves the class type based on the class mappings and the value
+      # rubocop:disable MethodLength
+      def self.add_class_selector_method(attribute, class_mappings)
+        method_name = :"select_#{attribute}_class"
+
+        define_singleton_method(method_name) do |value|
+          parsed_class_mappings = get_mappings(attribute, class_mappings)
+
+          # No class conversion if the value is nil
+          return nil if value.nil?
+
+          if value.is_a?(Hash)
+            # Allow setting of the value using a hash
+            return NilClass if value.empty?
+
+            # Find the first class mapping whose check returns true
+            check, full_class, partial_class = parsed_class_mappings.find { |check, _, _| check.call(value) }
+            raise SBF::Client::Error, "unknown #{attribute} type" if check.nil?
+
+            # If a user specifies exactly the partial fields, then this should be a partial.
+            return partial_class if partial_class && (value.keys - partial_class.attributes.to_a).empty?
+
+            # Otherwise
+            return full_class if full_class
+
+          else
+            # No class conversion if the value is already an entity
+            return nil if parsed_class_mappings.any? { |_, c1, c2|
+              [c1, c2].compact.any? { |allowed_class|
+                if allowed_class.instance_of?(Class)
+                  # Otherwise, return true if the value is an instance of the allowed class
+                  value.is_a?(allowed_class)
+
+                elsif allowed_class.instance_of?(Module)
+                  # If we specified a module, assume this is an enum and return true if the value
+                  # is one of the valid constant values for the module
+                  allowed_class.constants.any? { |const_name| allowed_class.const_get(const_name) == value }
+
+                end
+              }
+            }
+
+            # Convert to child class if given class is a parent of the same name
+            parsed_class_mappings.each { |_, c1, c2|
+              [c1, c2].compact.each { |allowed_class|
+                return allowed_class if allowed_class.ancestors.find { |a| a == value.class && a.demodulize == value.class.demodulize }
+              }
+            }
+
+            # Don't know how to handle whatever the user entered. Raise an error.
+            # (Nil and Hash are always valid values)
+            valid_classes = ['NilClass', Hash]
+            parsed_class_mappings.each do |_, class1, class2|
+              valid_classes << class1
+              valid_classes << class2 unless class2.nil?
+            end
+
+            raise SBF::Client::Error, "Unsupported value for #{name}.#{attribute}: #{value}. Should be one of #{valid_classes.join(', ')}"
+          end
+        end
+
+        private_class_method method_name
+      end
+      # rubocop:enable MethodLength
+      private_class_method :add_class_selector_method
+
+      def self.get_mappings(attribute, class_mappings)
+        # Parse the mappings information and save it off
+        mapping_var = :"@#{attribute}_class_mappings"
+        unless instance_variable_defined?(mapping_var)
+          instance_variable_set(mapping_var, parse_class_mappings(class_mappings))
+        end
+
+        instance_variable_get(mapping_var)
+      end
+      private_class_method :get_mappings
+
+      # Validates the input structure of the class mappings array and returns a new array with the class strings
+      # converted to actual classes
+      def self.parse_class_mappings(mappings)
+        raise SBF::Client::Error, "Invalid class mapping structure: #{mappings.class}" unless mappings.is_a?(Array)
+
+        mappings.map do |check, full_class, partial_class|
+          raise SBF::Client::Error, "Invalid class mapping check: #{check.class}" unless check.is_a?(Proc)
+
+          full_class = full_class.to_class
+          unless full_class.nil? || full_class.is_a?(NilClass) || full_class.ancestors.include?(BaseEntity) || full_class.instance_of?(Module)
+            raise SBF::Client::Error, "Invalid class mapping full class: #{full_class}"
+          end
+
+          partial_class = partial_class.to_class
+          unless partial_class.nil? || partial_class.is_a?(NilClass) || partial_class.ancestors.include?(BaseEntity)
+            raise SBF::Client::Error, "Invalid class mapping partial class: #{partial_class}"
+          end
+
+          [check, full_class, partial_class]
+        end
+      end
+      private_class_method :parse_class_mappings
+
+      # Convert the value to an instance of the appropriate class.
+      def convert_value(attribute, value)
+        entity_class_selector_method = :"select_#{attribute}_class"
+        entity_class = self.class.send(entity_class_selector_method, value)
+
+        # If the entity_class is nil, then that means don't convert anything
+        return value if entity_class.nil?
+
+        # If the entity_class is the NilClass, return nil
+        return nil if entity_class == NilClass
+
+        # If we are converting to a subclass, we need to first grab the hash of data from the parent object
+        value = value.to_hash if !value.is_a?(Hash) && value.respond_to?(:to_hash)
+
+        # Convert to an instance of the appropriate entity class.
+        entity_class.new(value)
+      end
+      private :convert_value
+
+      # Base entity setter. Allows for the property to be an array of types.
+      def self.add_multitype_setter_method(attribute, class_mappings, private_method = false)
+        add_class_selector_method(attribute, class_mappings)
+
+        method_name = :"#{attribute}="
+        define_method(method_name) do |value|
+          instance_variable_set(:"@#{attribute}", convert_value(attribute, value))
+        end
+
+        # Make the setter private if requested (so you can set through the constructor but not anywhere else)
+        private method_name if private_method
+      end
+      private_class_method :add_multitype_setter_method
+
+      # Base collection setter. Allows for the collection to be an array types of types.
+      def self.add_multitype_collection_setter_method(attribute, class_mappings, private_method = false)
+        add_class_selector_method(attribute, class_mappings)
+
+        define_method(:"#{attribute}=") do |values|
+          values ||= []
+          raise SBF::Client::Error, "#{attribute} must be an array" unless values.is_a?(Array)
+          converted_collection = values.map { |value| convert_value(attribute, value) }
+          instance_variable_set(:"@#{attribute}", converted_collection)
+        end
+
+        # Make the setter private if requested (so you can set through the constructor but not anywhere else)
+        private :"#{attribute}=" if private_method
+      end
+      private_class_method :add_multitype_collection_setter_method
+
+      # Recursively converts an entity into a Hash
+      def to_hash
+        entity_hash = {}
+        self.class.attributes.each { |key|
+          # If the method was not retrieved, do not include it in the hash
+          next if not_provided_attributes.include?(key)
+
+          # Get the value
+          value = send(key)
+
+          # If the value is an Entity, call to_hash on it (recursively)
+          if value.is_a?(BaseEntity)
+            entity_hash[key] = value.to_hash
+
+          # If the value is an Array, need to try to call to_hash on each item
+          elsif value.is_a?(Array)
+            entity_hash[key] = value.map { |element|
+              if element.is_a?(BaseEntity)
+                next element.to_hash
+              else
+                next element
+              end
+            }
+
+          # Collections should return empty array rather than nil
+          elsif value.nil? && self.class.collection_attributes.include?(key)
+            entity_hash[key] = []
+
+          # Just set the value
+          else
+            entity_hash[key] = value
+
+          end
+        }
+
+        # Return the hash
+        entity_hash
+      end
+
+      # Recursively convert an entity into json
+      def to_json(*a)
+        to_hash.to_json(*a)
+      end
+
+      def self.inherited(base)
+        # Add all of our attributes to the class that is inheriting us.
+        base.attributes.merge(attributes) unless attributes.empty?
+        base.optional_attributes.merge(optional_attributes) unless optional_attributes.empty?
+        base.entity_attributes.merge(entity_attributes) unless entity_attributes.empty?
+      end
+    end
+  end
+end