rescue_groups 0.0.1

data/docs/event_field.md

@@ -0,0 +1,20 @@
+## Event Fields
+* id
+* org_id
+* name
+* event_start
+* event_end
+* url
+* description
+* location_id
+* species
+* location_name
+* location_url
+* location_address
+* location_city
+* location_state
+* location_postal_code
+* location_country
+* location_phone
+* location_phone_ext
+* location_events

data/docs/organization_field.md

@@ -0,0 +1,25 @@
+## Organization Fields
+* id
+* about
+* adoption_process
+* adoption_url
+* common_application_accept
+* donation_url
+* email
+* facebook_url
+* fax
+* location
+* location_address
+* location_city
+* location_country
+* location_postal
+* location_state
+* location_zip_plus_4
+* meet_pets
+* name
+* phone
+* serve_areas
+* services
+* sponsorship_url
+* type
+* website_url

data/fields/animal_field.rb

@@ -0,0 +1,152 @@
+module RescueGroups
+  class AnimalField
+    FIELDS = {
+      id:                        :animalID,
+      organization_id:           :animalOrgID,
+      activity_level:            :animalActivityLevel,
+      adoption_fee:              :animalAdoptionFee,
+      altered:                   :animalAltered,
+      available_date:            :animalAvailableDate,
+      birthdate:                 :animalBirthdate,
+      birthdate_exact:           :animalBirthdateExact,
+      breed:                     :animalBreed,
+      coat_length:               :animalCoatLength,
+      color:                     :animalColor,
+      color_id:                  :animalColorID,
+      color_details:             :animalColorDetails,
+      courtesy:                  :animalCourtesy,
+      declawed:                  :animalDeclawed,
+      description:               :animalDescription,
+      description_plain:         :animalDescriptionPlain,
+      distinguishing_marks:      :animalDistinguishingMarks,
+      ear_type:                  :animalEarType,
+      energy_level:              :animalEnergyLevel,
+      excercise_needs:           :animalExerciseNeeds,
+      eye_color:                 :animalEyeColor,
+      fence:                     :animalFence,
+      found:                     :animalFound,
+      found_date:                :animalFoundDate,
+      found_postal_code:         :animalFoundPostalcode,
+      general_age:               :animalGeneralAge,
+      general_size_potential:    :animalGeneralSizePotential,
+      grooming_needs:            :animalGroomingNeeds,
+      house_trained:             :animalHousetrained,
+      indoor_outdoor:            :animalIndoorOutdoor,
+      kill_date:                 :animalKillDate,
+      kill_reason:               :animalKillReason,
+      location:                  :animalLocation,
+      # location_distance:         :animalLocationDistance,
+      location_city_state:       :animalLocationCitystate,
+      microchipped:              :animalMicrochipped,
+      mixed_breed:               :animalMixedBreed,
+      name:                      :animalName,
+      special_needs:             :animalSpecialneeds,
+      special_needs_description: :animalSpecialneedsDescription,
+      needs_foster:              :animalNeedsFoster,
+      new_people:                :animalNewPeople,
+      not_house_trained_reason:  :animalNotHousetrainedReason,
+      obedience_training:        :animalObedienceTraining,
+      ok_with_adults:            :animalOKWithAdults,
+      ok_with_cats:              :animalOKWithCats,
+      ok_with_dogs:              :animalOKWithDogs,
+      ok_with_kids:              :animalOKWithKids,
+      owner_experience:          :animalOwnerExperience,
+      pattern:                   :animalPattern,
+      pattern_id:                :animalPatternID,
+      adoption_pending:          :animalAdoptionPending,
+      primary_breed:             :animalPrimaryBreed,
+      primary_breed_id:          :animalPrimaryBreedID,
+      rescue_id:                 :animalRescueID,
+      search_string:             :animalSearchString,
+      secondary_breed:           :animalSecondaryBreed,
+      secondary_breed_id:        :animalSecondaryBreedID,
+      sex:                       :animalSex,
+      shedding:                  :animalShedding,
+      size_current:              :animalSizeCurrent,
+      size_potential:            :animalSizePotential,
+      size_uom:                  :animalSizeUOM,
+      species:                   :animalSpecies,
+      species_id:                :animalSpeciesID,
+      sponsorable:               :animalSponsorable,
+      sponsors:                  :animalSponsors,
+      sponsorhip_details:        :animalSponsorshipDetails,
+      sponsorship_minimum:       :animalSponsorshipMinimum,
+      status:                    :animalStatus,
+      status_id:                 :animalStatusID,
+      summary:                   :animalSummary,
+      tail_type:                 :animalTailType,
+      thumbnail_url:             :animalThumbnailUrl,
+      up_to_date:                :animalUptodate,
+      updated_date:              :animalUpdatedDate,
+      url:                       :animalUrl,
+      vocal:                     :animalVocal,
+      yard_required:             :animalYardRequired,
+      affectionate:              :animalAffectionate,
+      apartment:                 :animalApartment,
+      crate_trained:             :animalCratetrained,
+      drools:                    :animalDrools,
+      eager_to_please:           :animalEagerToPlease,
+      escapes:                   :animalEscapes,
+      even_tempered:             :animalEventempered,
+      fetches:                   :animalFetches,
+      gentle:                    :animalGentle,
+      good_in_car:               :animalGoodInCar,
+      goofy:                     :animalGoofy,
+      has_allergies:             :animalHasAllergies,
+      hearing_impaired:          :animalHearingImpaired,
+      hypoallergenic:            :animalHypoallergenic,
+      independent:               :animalIndependent,
+      intelligent:               :animalIntelligent,
+      lap:                       :animalLap,
+      leash_trained:             :animalLeashtrained,
+      needs_companion_animal:    :animalNeedsCompanionAnimal,
+      no_cold:                   :animalNoCold,
+      no_female_dogs:            :animalNoFemaleDogs,
+      no_heat:                   :animalNoHeat,
+      no_large_dogs:             :animalNoLargeDogs,
+      no_male_dogs:              :animalNoMaleDogs,
+      no_small_dogs:             :animalNoSmallDogs,
+      obedient:                  :animalObedient,
+      ok_for_seniors:            :animalOKForSeniors,
+      ok_with_farm_animals:      :animalOKWithFarmAnimals,
+      older_kids_only:           :animalOlderKidsOnly,
+      ongoing_medical:           :animalOngoingMedical,
+      playful:                   :animalPlayful,
+      plays_toys:                :animalPlaysToys,
+      predatory:                 :animalPredatory,
+      protective:                :animalProtective,
+      sight_impaired:            :animalSightImpaired,
+      skittish:                  :animalSkittish,
+      special_diet:              :animalSpecialDiet,
+      swims:                     :animalSwims,
+      timid:                     :animalTimid,
+      foster_email:              :fosterEmail,
+      foster_first_name:         :fosterFirstname,
+      foster_last_name:          :fosterLastname,
+      foster_name:               :fosterName,
+      foster_phone_cell:         :fosterPhoneCell,
+      foster_phone_home:         :fosterPhoneHome,
+      foster_salutation:         :fosterSalutation,
+      location_addresss:         :locationAddress,
+      location_city:             :locationCity,
+      location_country:          :locationCountry,
+      location_url:              :locationUrl,
+      location_name:             :locationName,
+      location_phone:            :locationPhone,
+      location_state:            :locationState,
+      location_postal_code:      :locationPostalcode,
+      pictures:                  :animalPictures,
+      videos:                    :animalVideos,
+      video_urls:                :animalVideoUrls,
+    }.freeze
+
+    # method: all
+    # purpose: Return the values of FIELDS for easy use in
+    #            requesting fields from the remote API
+    # param: none
+    # return: <Array[Symbol]> - All defined field names
+    def self.all
+      FIELDS.values
+    end
+  end
+end

data/fields/event_field.rb

@@ -0,0 +1,35 @@
+module RescueGroups
+  class EventField
+    FIELDS = {
+      id:                   :eventID,
+      org_id:               :eventOrgID,
+      name:                 :eventName,
+      event_start:          :eventStart,
+      event_end:            :eventEnd,
+      url:                  :eventUrl,
+      description:          :eventDescription,
+      location_id:          :eventLocationID,
+      # location_distance:    :eventLocationDistance, # seems to have been deprecated
+      species:              :eventSpecies,
+      location_name:        :locationName,
+      location_url:         :locationUrl,
+      location_address:     :locationAddress,
+      location_city:        :locationCity,
+      location_state:       :locationState,
+      location_postal_code: :locationPostalcode,
+      location_country:     :locationCountry,
+      location_phone:       :locationPhone,
+      location_phone_ext:   :locationPhoneExt,
+      location_events:      :locationEvents,
+    }.freeze
+
+    # method: all
+    # purpose: Return the values of FIELDS for easy use in
+    #            requesting fields from the remote API
+    # param: none
+    # return: <Array[Symbol]> - All defined field names
+    def self.all
+      FIELDS.values
+    end
+  end
+end

data/fields/organization_field.rb

@@ -0,0 +1,40 @@
+module RescueGroups
+  class OrganizationField
+    FIELDS = {
+      about:                     :orgAbout,
+      adoption_process:          :orgAdoptionProcess,
+      adoption_url:              :orgAdoptionUrl,
+      common_application_accept: :orgCommonapplicationAccept,
+      donation_url:              :orgDonationUrl,
+      email:                     :orgEmail,
+      facebook_url:              :orgFacebookUrl,
+      fax:                       :orgFax,
+      id:                        :orgID,
+      location:                  :orgLocation,
+      location_address:          :orgAddress,
+      location_city:             :orgCity,
+      location_country:          :orgCountry,
+      # location_distance:         :orgLocationDistance, # Seems to have been removed
+      location_postal:           :orgPostalcode,
+      location_state:            :orgState,
+      location_zip_plus_4:       :orgPlus4,
+      meet_pets:                 :orgMeetPets,
+      name:                      :orgName,
+      phone:                     :orgPhone,
+      serve_areas:               :orgServeAreas,
+      services:                  :orgServices,
+      sponsorship_url:           :orgSponsorshipUrl,
+      type:                      :orgType,
+      website_url:               :orgWebsiteUrl,
+    }.freeze
+
+    # method: all
+    # purpose: Return the values of FIELDS for easy use in
+    #            requesting fields from the remote API
+    # param: none
+    # return: <Array[Symbol]> - All defined field names
+    def self.all
+      FIELDS.values
+    end
+  end
+end

data/fields/picture_field.rb

@@ -0,0 +1,30 @@
+module RescueGroups
+  class PictureField
+    FIELDS = {
+      mediaID:              :id,
+      mediaOrder:           :order,
+      lastUpdated:          :updated_at,
+      fileSize:             :file_size,
+      resolutionX:          :resolution_x,
+      resolutionY:          :resolution_y,
+      fileNameFullsize:     :file_name_full_size,
+      fileNameThumbnail:    :file_name_thumbnail,
+      urlSecureFullsize:    :url_full,
+      urlSecureThumbnail:   :url_thumbnail,
+      urlInsecureFullsize:  :insecure_url_full,
+      urlInsecureThumbnail: :insecure_url_thumb,
+      original:             :original,
+      large:                :large,
+      small:                :small
+    }.freeze
+
+    # method: all
+    # purpose: Return the values of FIELDS for easy use in
+    #            requesting fields from the remote API
+    # param: none
+    # return: <Array[Symbol]> - All defined field names
+    def self.all
+      FIELDS.values
+    end
+  end
+end

data/lib/api_client.rb

@@ -0,0 +1,29 @@
+require_relative './remote_client'
+
+module RescueGroups
+  module ApiClient
+    # This method is called when the ApiClient Module is included
+    #   in a class.
+    def self.included(base)
+      base.class_eval do
+        # method: api_client
+        # purpose: Return or instantiate a new RemoteClient class to
+        #          handle all details of talking to the third party
+        #          RescueGroups API
+        # param: none
+        # return: RemoteClient
+        def self.api_client
+          @api_client ||= RemoteClient.new
+        end
+
+        # method: api_client
+        # purpose: delegate to class method to retrieve remote client
+        # param: none
+        # return: result of self.api_client
+        def api_client
+          self.class.api_client
+        end
+      end
+    end
+  end
+end

data/lib/queryable.rb

@@ -0,0 +1,79 @@
+require_relative './requests/find'
+require_relative './requests/where'
+
+module RescueGroups
+  class NotFound < StandardError; end
+  class InvalidRequest < StandardError; end
+
+  module Queryable
+    # This method is called when the Queryable Module is included
+    #   in a class.
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # method: find
+      # purpose: find one or many objects by primary key (id)
+      # param: ids Array<Integer> primary key(s) of object(s) that will
+      #          be requested
+      # return: One found object if one id was given, otherwise an array of found objects
+      #         If the response was not successful, an exception is thrown
+      def find(ids)
+        find_request = Requests::Find.new(ids, self, api_client)
+
+        response = find_request.request
+
+        unless response.success? && !response['data'].nil? && !response['data'].empty?
+          fail(NotFound, "Unable to find #{ self.name } with id: #{ ids }")
+        end
+
+        objects = response['data'].map { |data| new(data) }
+
+        [*ids].flatten.length == 1 ? objects.first : objects
+      end
+
+      # method: where
+      # purpose: find one or many objects by any supported filters
+      # param: conditions - <Hash> - mutliple keyed hash containing
+      #          the conditions to search against.
+      #        example: { breed: 'daschund' }
+      # return: <Array> -An array of found objects
+      #         If the response was not successful, an exception is thrown
+      def where(conditions)
+        return find(conditions[:id]) if conditions.keys == [:id]
+
+        where_request = Requests::Where.new(conditions, self, api_client, search_engine_class)
+
+        response = where_request.request
+
+        fail(InvalidRequest, "Problem with request #{ response.error }") unless response.success?
+
+        response_with_additional = additional_request_data(where_request)
+
+        response_with_additional['data'].map do |_data_id, data|
+          new(data)
+        end
+      end
+
+      private
+
+      def additional_request_data(request)
+        unless RescueGroups.config.load_all_results && request.can_request_more?
+          return request.results
+        end
+
+        (request.results['found_rows'] / request.search_engine.limit).times.each do |i|
+          request.update_conditions!(limit: request.search_engine.limit * (i + 1))
+
+          additional_results_response = request.request
+          if !additional_results_response.success?
+            fail(InvalidRequest, "Problem with request #{ additional_results_response.error }")
+          end
+        end
+
+        request.results
+      end
+    end
+  end
+end

data/lib/relationable.rb

@@ -0,0 +1,76 @@
+module RescueGroups
+  module Relationable
+    # This method is called when the Relationable Module is included
+    #   in a class.
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      # method: belongs_to
+      # purpose: define methods that denote a relationship
+      #            between the class including this module
+      #            and another.
+      #          When included, it defines methods: relationship_id
+      #                                             relationship_id=
+      #                                             relationship
+      #                                             relationship=
+      # example:
+      #    class Foo
+      #      include Relationable
+      #
+      #      belongs_to :bar
+      #    end
+      #
+      # param: relationship - <Symbol> - name of the class that a relationship
+      #          is intended for
+      # return: nil
+      def belongs_to(relationship)
+        define_method relationship do
+          model = instance_variable_get(:"@#{ relationship }")
+          return model unless model.nil?
+
+          relationship_id = self.send(:"#{ relationship }_id")
+
+          unless relationship_id.nil?
+            klass = RescueGroups.constantize(relationship)
+
+            self.send(:"#{ relationship }=", klass.find(relationship_id))
+          end
+        end
+
+        attr_writer relationship
+        attr_accessor :"#{ relationship }_id"
+      end
+      # method: has_many
+      # purpose: define methods that denote a relationship
+      #            between the class including this module
+      #            and another.
+      #          When included, it defines methods: relationship
+      #                                             relationship=
+      # example:
+      #    class Foo
+      #      include Relationable
+      #
+      #      has_many :bars
+      #    end
+      #
+      # param: relationship - <Symbol> - name of the class that a relationship
+      #          is intended for
+      # return: nil
+      def has_many(relationship)
+        define_method relationship do
+          temp = instance_variable_get(:"@#{ relationship }")
+
+          return temp unless temp.nil? || temp.empty?
+
+          klass = RescueGroups.constantize(relationship)
+          foreign_key = "#{ self.class.to_s.split('::').last.downcase }_id"
+          klass.where(foreign_key.to_sym => @id)
+        end
+
+        attr_writer relationship
+      end
+    end
+  end
+end