stbaldricks 1.5.1.pre

data/lib/stbaldricks/endpoints/message.rb

@@ -0,0 +1,27 @@
+require 'stbaldricks/endpoints/lib/entity'
+
+module SBF
+  module Client
+    class MessageEndpoint < SBF::Client::EntityEndpoint
+      def mark_as_read(message_id)
+        raise SBF::Client::Error, 'Message Id must be an Integer' unless message_id.is_a?(Integer)
+
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/mark_as_read/#{message_id}")
+
+        error = SBF::Client::ErrorEntity.new(response) unless ok?(response)
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: response, error: error)
+      end
+
+      def mark_as_unread(message_id)
+        raise SBF::Client::Error, 'Message Id must be an Integer' unless message_id.is_a?(Integer)
+
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/mark_as_unread/#{message_id}")
+
+        error = SBF::Client::ErrorEntity.new(response) unless ok?(response)
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: response, error: error)
+      end
+    end
+  end
+end

data/lib/stbaldricks/endpoints/newsletter_recipient.rb

@@ -0,0 +1,41 @@
+require 'stbaldricks/endpoints/lib/entity'
+
+module SBF
+  module Client
+    class NewsletterRecipientEndpoint < EntityEndpoint
+      def subscribe(entity_or_email, first_name = nil, last_name = nil, welcome_email = true)
+        if entity_or_email.is_a?(String) && entity_or_email && first_name && last_name
+          entity = target_class.new(email_address: entity_or_email, first_name: first_name, last_name: last_name, welcome_email: welcome_email)
+        elsif entity_or_email.is_a?(SBF::Client::BaseEntity)
+          entity = entity_or_email
+        else
+          raise SBF::Client::Error, 'Invalid Entity'
+        end
+
+        data = entity.to_hash
+
+        response = SBF::Client::Api::Request.public_post_request("#{base_uri}/subscribe", data)
+        error = SBF::Client::ErrorEntity.new(JSON.parse(response.body).symbolize!) unless ok?(response)
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: nil, error: error)
+      end
+
+      def unsubscribe(entity_or_email)
+        if entity_or_email.is_a?(String)
+          entity = target_class.new(email_address: entity_or_email)
+        elsif entity_or_email.is_a?(SBF::Client::BaseEntity)
+          entity = entity_or_email
+        else
+          raise SBF::Client::Error, 'Invalid Entity'
+        end
+
+        data = entity.to_hash
+
+        response = SBF::Client::Api::Request.public_post_request("#{base_uri}/unsubscribe", data)
+        error = SBF::Client::ErrorEntity.new(JSON.parse(response.body).symbolize!) unless ok?(response)
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: nil, error: error)
+      end
+    end
+  end
+end

data/lib/stbaldricks/endpoints/participant.rb

@@ -0,0 +1,66 @@
+require 'stbaldricks/endpoints/lib/entity'
+
+module SBF
+  module Client
+    class ParticipantEndpoint < EntityEndpoint
+      def join_team(participant_id, new_team_id)
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/move_to_different_team", id: participant_id, new_team_id: new_team_id)
+
+        if ok?(response)
+          data = SBF::Client::FullParticipant.new(JSON.parse(response.body).symbolize!)
+        else
+          error = SBF::Client::ErrorEntity.new(JSON.parse(response.body).symbolize!)
+        end
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: data, error: error)
+      end
+
+      def start_team(participant_id, team_name, fundraising_goal)
+        response = SBF::Client::Api::Request.post_request(
+          "#{base_uri}/move_to_different_team",
+          id: participant_id,
+          new_team_id: 0,
+          team_name: team_name,
+          goal: fundraising_goal,
+          how_created: SBF::Client::Team::HowCreated::WEBSITE)
+
+        if ok?(response)
+          data =  SBF::Client::FullParticipant.new(JSON.parse(response.body).symbolize!)
+        else
+          error = SBF::Client::ErrorEntity.new(JSON.parse(response.body).symbolize!)
+        end
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: data, error: error)
+      end
+
+      def leave_team(participant_id)
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/move_to_different_team", id: participant_id, new_team_id: 0)
+
+        if ok?(response)
+          data = SBF::Client::FullParticipant.new(JSON.parse(response.body).symbolize!)
+        else
+          error = SBF::Client::ErrorEntity.new(JSON.parse(response.body).symbolize!)
+        end
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: data, error: error)
+      end
+
+      def delete_role(participant_id, role)
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/delete_role", participant_id: participant_id, role: role)
+
+        error = SBF::Client::ErrorEntity.new(JSON.parse(response.body).symbolize!) unless ok?(response)
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: nil, error: error)
+      end
+
+      def move_to_different_event(participant_id, new_event_id)
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/move_to_different_event",
+                                                          id: participant_id, new_event_id: new_event_id)
+
+        error = SBF::Client::ErrorEntity.new(JSON.parse(response.body).symbolize!) unless ok?(response)
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: nil, error: error)
+      end
+    end
+  end
+end

data/lib/stbaldricks/endpoints/photo.rb

@@ -0,0 +1,51 @@
+require 'stbaldricks/endpoints/lib/entity'
+
+module SBF
+  module Client
+    class PhotoEndpoint < SBF::Client::EntityEndpoint
+      def create(entity, with = {})
+        raise SBF::Client::Error, 'Invalid Entity' unless entity.is_a?(SBF::Client::BaseEntity)
+
+        with = normalize_with(with)
+
+        create_data = entity.to_hash
+        filename = create_data.delete(:filename)
+        file = create_data.delete(:file)
+        create_data.store(:with, with)
+
+        response = SBF::Client::Api::Request.file_post_request(path: "#{base_uri}/create", params: create_data, file: file, filename: filename)
+
+        entity, error = hydrate_entity(response, create_data, entity)
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: entity, error: error)
+      end
+
+      def update(_id = nil, entity_or_hash = nil, with = {})
+        if entity_or_hash.is_a?(SBF::Client::BaseEntity)
+          # If someone has passed in an entity, just convert it to a hash
+          data = entity_or_hash.to_hash
+        elsif entity_or_hash.is_a?(Hash)
+          # If someone has passed in a hash, make sure all of it's values match fields in the entity class
+          data = sanitize(entity_or_hash)
+        else
+          raise SBF::Client::Error, 'Invalid Data'
+        end
+
+        filename = data.delete(:filename)
+        file = data.delete(:file)
+
+        with = normalize_with(with)
+        data[:with] = with
+        response = if file
+                     SBF::Client::Api::Request.file_post_request(path: "#{base_uri}/update", params: data, file: file, filename: filename)
+                   else
+                     SBF::Client::Api::Request.post_request("#{base_uri}/update", data)
+                   end
+
+        data, error = hydrate_entity(response, data, entity_or_hash)
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: data, error: error)
+      end
+    end
+  end
+end

data/lib/stbaldricks/endpoints/recurring_gift.rb

@@ -0,0 +1,18 @@
+require 'stbaldricks/endpoints/lib/entity'
+
+module SBF
+  module Client
+    class RecurringGiftEndpoint < SBF::Client::EntityEndpoint
+      def sync(data)
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/sync", data)
+
+        unless ok?(response)
+          parsed_response_body = JSON.parse(response.body).symbolize!
+          error = SBF::Client::ErrorEntity.new(parsed_response_body)
+        end
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: response, error: error)
+      end
+    end
+  end
+end

data/lib/stbaldricks/endpoints/search.rb

@@ -0,0 +1,63 @@
+require 'stbaldricks/endpoints/lib/entity'
+
+module SBF
+  module Client
+    class SearchEndpoint < EntityEndpoint
+      # Find entities in search matching the provided search term and/or filters.
+      #
+      # @param [String|Array] model_type The type or types of entities to include in the results.
+      # @param [String] search_text A search term to filter the results.
+      # @param [Array] filters Filters to apply to the results. The array should contain hashes with the column, value and operator of the filter.
+      #                           (i.e.) [{column: 'event_id', value: [11560, 11016,11378,11163], operator: 'in'}]
+      # @param [Hash] geo_location The location details for performing a radius search. The hash should contain the lat, lon and distance.
+      #                           (i.e.) {distance: 5, lat: 40.754567, lon: -96.695894}
+      # @param [Hash] options An hash containing options for ordering, applying a limit and offset to the results.
+      # @option options [Hash] :order The ordering to apply to the results. The hash should contain the field_name to order on
+      #                           as well as the direction. (i.e.) {field_name: 'foo', direction: 'asc'}
+      # @option [Integer] :limit The maximum number of results to return.
+      # @option [Integer] :offset The query offset.
+      # @return [Client::Api::Response] The data attribute on a successful response will be
+      #                                 an array of search entities matching the model type(s) specified
+      def find(model_type, search_text = nil, filters = [], geo_location = {}, options = {})
+        if [search_text, filters, geo_location].all?(&:empty?)
+          raise SBF::Client::Error, 'Must provide either a search_text, filter or geo_location for the query'
+        end
+
+        model_type = Array(model_type).to_json unless model_type.empty?
+        filters = filters.to_json unless filters.empty?
+        geo_location = geo_location.to_json unless geo_location.empty?
+
+        # Build the parameter list for search
+        params, response_data = {}, {}
+        {model_type: model_type, search_text: search_text, filters: filters, geo_location: geo_location}.each do |k, v|
+          params[k.to_sym] = v unless v.empty?
+        end
+
+        options.each do |k, v|
+          params[k.to_sym] = v.is_a?(Hash) ? v.to_json : v unless v.empty?
+        end
+
+        response = SBF::Client::Api::Request.get_request("#{base_uri}/search", params)
+        parsed_response_body = JSON.parse(response.body).symbolize!
+
+        if ok?(response)
+          parsed_response_body = JSON.parse(parsed_response_body[:response]).symbolize!
+
+          response_data[:total_count] = parsed_response_body[:hits][:total]
+          response_data[:results] = [].tap do |arr|
+            parsed_response_body[:hits][:hits].each do |entity_data|
+              arr << target_class.const_get(entity_data[:_type].capitalize).new(entity_data[:_source])
+            end
+          end
+
+          data = response_data
+        else
+          data = nil
+          error = SBF::Client::ErrorEntity.new(parsed_response_body)
+        end
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: data, error: error)
+      end
+    end
+  end
+end

data/lib/stbaldricks/endpoints/shave_schedule.rb

@@ -0,0 +1,28 @@
+require 'stbaldricks/endpoints/lib/entity'
+
+module SBF
+  module Client
+    class ShaveScheduleEndpoint < SBF::Client::EntityEndpoint
+      def get(id, year, with = {})
+        super("#{id}/#{year}", with)
+      end
+
+      def update(id, year, data, with = {})
+        super("#{id}/#{year}", data, with)
+      end
+
+      def notify(data)
+        response = SBF::Client::Api::Request.post_request("#{base_uri}/notify", data)
+
+        if ok?(response)
+          data = nil
+        else
+          parsed_response_body = JSON.parse(response.body).symbolize!
+          error = SBF::Client::ErrorEntity.new(parsed_response_body)
+        end
+
+        SBF::Client::Api::Response.new(http_code: response.code, data: data, error: error)
+      end
+    end
+  end
+end

data/lib/stbaldricks/endpoints/user.rb

@@ -0,0 +1,106 @@
+require 'stbaldricks/endpoints/lib/entity'
+
+module SBF
+  module Client
+    class UserEndpoint < EntityEndpoint
+      # Logs in a user and configures the client library to use user credentials for subsequent requests.
+      # Returns the access token for the user that should be held onto to configure the client library in
+      # future requests that are outside of this scope.
+      #
+      # @param username [string]
+      # @param password [string]
+      # @return [string]
+      def login!(username, password)
+        response = SBF::Client::Api::Request.public_post_request(
+          "/#{SBF::Client::Api::VERSION}/security/login",
+          username: username,
+          password: password
+        )
+        parsed_response = JSON.parse(response.body).symbolize!
+
+        if ok?(response)
+          SBF::Client::Configuration.user_token = parsed_response[:token]
+          data = parsed_response.merge(user: target_class.new(parsed_response[:user]))
+        else
+          SBF::Client::Configuration.user_token = nil
+          error = SBF::Client::ErrorEntity.new(parsed_response)
+        end
+
+        SBF::Client::LOG.info { "SBF::Client - User Login: #{username}, Token: #{parsed_response[:token]}" }
+        SBF::Client::Api::Response.new(http_code: response.code, data: data, error: error)
+      end
+
+      # Returns array of entity hash info for the entities logged in user has access to for requested permission.
+      #
+      # @raise [SBFClientError]
+      def list_entities_user_has_permission(permission_id, event_years)
+        raise SBF::Client::Error, 'User not logged in' if  SBF::Client::Configuration.user_token.nil?
+
+        event_years = [event_years] if event_years.is_a? Fixnum
+
+        response = SBF::Client::Api::Request.post_request(
+          "/#{SBF::Client::Api::VERSION}/security/list_entities_user_has_permission",
+          permission_id: permission_id,
+          event_years: event_years
+        )
+        parsed_response = JSON.parse(response.body).symbolize!
+
+        if ok?(response)
+          data = parsed_response
+        else
+          error = SBF::Client::ErrorEntity.new(parsed_response)
+        end
+
+        SBF::Client::LOG.info { "SBF::Client - User List Entities User Has Permission: #{permission_id}, #{event_years}, Entities: #{data}" }
+        SBF::Client::Api::Response.new(http_code: response.code, data: data, error: error)
+      end
+
+      # Changes the password of the user associated with the given profile_id
+      #
+      # @raise [SBFClientError]
+      def change_password(profile_id, password)
+        raise SBF::Client::Error, 'User not logged in' if  SBF::Client::Configuration.user_token.nil?
+
+        response = SBF::Client::Api::Request.post_request(
+          "/#{SBF::Client::Api::VERSION}/security/change_password",
+          profile_id: profile_id,
+          password: password
+        )
+
+        if ok?(response)
+          SBF::Client::Configuration.user_token = nil
+        else
+          SBF::Client::Configuration.user_token = nil
+          parsed_response = JSON.parse(response.body).symbolize!
+          error = SBF::Client::ErrorEntity.new(parsed_response)
+        end
+
+        SBF::Client::LOG.info { "SB::Client - Change Password for user with profile_id: #{profile_id}" }
+        SBF::Client::Api::Response.new(http_code: response.code, data: nil, error: error)
+      end
+
+      # Removes the Facebook user of the given profile_id
+      #
+      # @raise [SBFClientError]
+      def disconnect_facebook(profile_id)
+        raise SBF::Client::Error, 'User not logged in' if  SBF::Client::Configuration.user_token.nil?
+
+        response = SBF::Client::Api::Request.post_request(
+          "/#{SBF::Client::Api::VERSION}/user/disconnect_facebook",
+          profile_id: profile_id
+        )
+
+        if ok?(response)
+          SBF::Client::Configuration.user_token = nil
+        else
+          SBF::Client::Configuration.user_token = nil
+          parsed_response = JSON.parse(response.body).symbolize!
+          error = SBF::Client::ErrorEntity.new(parsed_response)
+        end
+
+        SBF::Client::LOG.info { "SB::Client - Disconnecting Facebook user with profile_id: #{profile_id}" }
+        SBF::Client::Api::Response.new(http_code: response.code, data: nil, error: error)
+      end
+    end
+  end
+end

data/lib/stbaldricks/entities/batch.rb

@@ -0,0 +1,29 @@
+require 'stbaldricks/entities/donation'
+require 'stbaldricks/entities/lib/top_level'
+require 'stbaldricks/entities/lib/payment'
+
+module SBF
+  module Client
+    class Batch < SBF::Client::TopLevelEntity
+      actions DEFAULT_CRUD_ACTIONS
+
+      module Type
+        IMPORTED = 'imported'
+        PROCESSED = 'processed'
+      end
+
+      attr_accessor :id
+      attr_accessor :type
+      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::NONCE }, 'SBF::Client::Payment::NonceDetails']
+        ]
+      )
+      attr_accessor :amount
+      attr_accessor :filename
+      attr_accessor :created_at, :modified_at, :processed_at, :submitted_by
+      entity_collection_attr_accessor :donations, 'SBF::Client::FullDonation', 'SBF::Client::PartialDonation'
+    end
+  end
+end

data/lib/stbaldricks/entities/campaign.rb

@@ -0,0 +1,37 @@
+require 'stbaldricks/entities/lib/fundraising_page'
+require 'stbaldricks/entities/lib/base'
+require 'stbaldricks/entities/lib/top_level'
+
+module SBF
+  module Client
+    class Campaign < SBF::Client::TopLevelEntity
+      action :get
+      action :find
+
+      disallow_instantiation
+
+      class Totals < SBF::Client::BaseEntity
+        attr_reader :current_year_amount_raised
+        attr_reader :previous_year_amount_raised
+        attr_reader :all_years_amount_raised
+        attr_reader :participants
+        attr_reader :shavees
+      end
+    end
+
+    class PartialCampaign < Campaign
+      attr_accessor :id
+    end
+
+    class FullCampaign < Campaign
+      attr_accessor :id
+      attr_accessor :name
+      attr_accessor :website_url
+
+      entity_attr_reader :totals, 'SBF::Client::Campaign::Totals', nil, true
+      entity_attr_accessor :web_page, 'SBF::Client::WebPage', nil, true
+
+      entity_attr_accessor :photo, 'SBF::Client::Photo', nil, true
+    end
+  end
+end