eventbrite_sdk 3.0.2

data/lib/eventbrite_sdk/exceptions.rb

@@ -0,0 +1,42 @@
+module EventbriteSDK
+  class EventbriteAPIError < RuntimeError
+    attr_reader :message, :response
+
+    def initialize(msg = '', response = :none)
+      @message = msg
+      @response = response
+    end
+
+    # Returns a hash with AT LEAST 'error_description'.
+    # When an error is raised manually there will be no response!
+    # This is handled by using the specified message as the error_description.
+    def parsed_error
+      default = %({"error_description": "#{message}"})
+      value = response_value(:body, fallback: default)
+
+      JSON.parse(value)
+    end
+
+    # Returns the status code of the response, or :none if there is no response.
+    def status_code
+      response_value(:code)
+    end
+
+    private
+
+    def response_value(key, fallback: :none)
+      if response.respond_to?(key)
+        response.send(key)
+      else
+        fallback
+      end
+    end
+  end
+
+  class BadRequest < EventbriteAPIError; end
+  class Forbidden < EventbriteAPIError; end
+  class InvalidAttribute < EventbriteAPIError; end
+  class InternalServerError < EventbriteAPIError; end
+  class ResourceNotFound < EventbriteAPIError; end
+  class Unauthorized < EventbriteAPIError; end
+end

data/lib/eventbrite_sdk/lists/owned_event_orders_list.rb

@@ -0,0 +1,27 @@
+module EventbriteSDK
+  module Lists
+    class OwnedEventOrdersList < ResourceList
+      def search(term)
+        send(:"term_provided_#{!!term}", term)
+
+        @pagination = { 'page_count' => 1, 'page_number' => 1 }
+
+        self
+      end
+
+      private
+
+      # Swaps the endpoint out to allow searches
+      def term_provided_true(term)
+        @url_base.sub!('owned_event_orders', 'search_owned_event_orders')
+        @query[:search_term] = term
+      end
+
+      # Swaps the endpoint out owned events, and removes the search_term query
+      def term_provided_false(_term)
+        @url_base.sub!('search_owned_event_orders', 'owned_event_orders')
+        @query.delete(:search_term)
+      end
+    end
+  end
+end

data/lib/eventbrite_sdk/media.rb

@@ -0,0 +1,77 @@
+module EventbriteSDK
+  # This module implements media upload to Eventbrite based on:
+  # https://docs.evbhome.com/apidocs/reference/uploads/?highlight=logo
+
+  class Media < Resource
+    resource_path 'media/:id'
+
+    attr_reader :image_type, :file
+
+    VALID_TYPES = {
+      event_logo: 'image-event-logo',
+      organizer_logo: 'image-organizer-logo',
+      user_photo: 'image-user-photo',
+      event_view_from_seat: 'image-event-view-from-seat',
+    }.freeze
+
+    schema_definition do
+      string 'crop_mask'
+      string 'original'
+      string 'id'
+      string 'url'
+      string 'aspect_ratio'
+      string 'edge_color'
+      string 'edge_color_set'
+    end
+
+    def upload!(image_type, file)
+      # Media uploads through the API involve a multiple step process:
+
+      # 1. Retrieve upload instructions + an upload token from the API
+      instructions = get_instructions(image_type)
+
+      # 2. Upload the file to the endpoint specified in the upload instructions
+      eventbrite_upload(file, instructions)
+
+      # 3. When the upload has finished, notify the API by re-sending the
+      #    upload token from step 1
+      notify(instructions['upload_token'])
+
+      true
+    end
+
+    private
+
+    def get_instructions(image_type, request = EventbriteSDK)
+      type = VALID_TYPES[image_type]
+
+      unless type
+        raise ArgumentError.new(
+          "image_type needs to be one of #{VALID_TYPES.keys}"
+        )
+      end
+
+      request.get(url: path('upload'), query: { type: type })
+    end
+
+    def eventbrite_upload(file, instructions)
+      RestClient.post(
+        instructions['upload_url'],
+        instructions['upload_data'].merge(file: file),
+        multipart: true,
+      )
+    end
+
+    def notify(upload_token, request = EventbriteSDK)
+      response = request.post(
+        url: path('upload'), payload: { upload_token: upload_token }
+      )
+
+      if payload['crop_mask']
+        response = request.post(url: path(response['id']), payload: payload)
+      end
+
+      reload(response)
+    end
+  end
+end

data/lib/eventbrite_sdk/order.rb

@@ -0,0 +1,25 @@
+module EventbriteSDK
+  class Order < Resource
+    resource_path 'orders/:id'
+
+    # Defines order#resend_confirmation_email and order#refund
+    #
+    # When an event has an id the POST is made, otherwise we return false
+    # POSTS to order/:id/(resend_confirmation_email|refunds)
+    define_api_actions :resend_confirmation_email, { refund: :refunds }
+
+    has_many :attendees, object_class: 'Attendee'
+    belongs_to :event, object_class: 'Event'
+
+    schema_definition do
+      string 'name'
+      string 'first_name'
+      string 'last_name'
+      string 'email'
+      string 'costs'
+      datetime 'created', read_only: true
+      datetime 'changed', read_only: true
+      string 'resource_uri', read_only: true
+    end
+  end
+end

data/lib/eventbrite_sdk/organizer.rb

@@ -0,0 +1,20 @@
+module EventbriteSDK
+  class Organizer < Resource
+    resource_path 'organizers/:id'
+
+    attributes_prefix 'organizer'
+
+    has_many :events, object_class: 'Event'
+
+    schema_definition do
+      string 'name'
+      string 'description.html'
+      string 'long_description.html'
+      string 'logo.id'
+      string 'website'
+      string 'twitter'
+      string 'facebook'
+      string 'instagram'
+    end
+  end
+end

data/lib/eventbrite_sdk/report.rb

@@ -0,0 +1,49 @@
+module EventbriteSDK
+  class Report
+    STRING_KEYS = %i(
+      start_date
+      end_date
+      date_facet
+      event_status
+      timezone
+      group_by
+    ).freeze
+
+    VALID_REPORTS = %i(attendees sales).freeze
+
+    def initialize
+      @query = {}
+    end
+
+    def event_ids(*ids)
+      @query[:event_ids] = ids.join(',')
+
+      self
+    end
+
+    def filter_by(filters)
+      @query[:filter_by] = filters.to_json
+
+      self
+    end
+
+    STRING_KEYS.each do |method|
+      define_method(method) do |value|
+        @query[method] = value
+        self
+      end
+    end
+
+    def query
+      @query.dup # Don't allow mutation
+    end
+
+    def retrieve(type = nil, sdk = EventbriteSDK)
+      unless VALID_REPORTS.include?(type)
+        raise ArgumentError, "`:type` is not of #{VALID_REPORTS}"
+      end
+
+      sdk.get(url: "reports/#{type}", query: query)
+    end
+  end
+end

data/lib/eventbrite_sdk/resource.rb

@@ -0,0 +1,99 @@
+module EventbriteSDK
+  class Resource
+    include Operations::AttributeSchema
+    include Operations::Endpoint
+    include Operations::Relationships
+
+    def self.build(attrs)
+      new.tap do |instance|
+        instance.assign_attributes(attrs)
+      end
+    end
+
+    # Allows compile time definition of POST methods
+    #
+    # Example:
+    #   class Event < Resource
+    #     define_api_actions :publish, :unpublish
+    #   end
+    #
+    # would defined instance methods like so:
+    #
+    # def publish
+    #   !new? && EventbriteSDK.post(url: path('publish'))
+    # end
+    #
+    # def publish
+    #   !new? && EventbriteSDK.post(url: path('unpublish'))
+    # end
+    def self.define_api_actions(*actions)
+      req = ->(inst, postfix) do
+        inst.instance_eval { !new? && EventbriteSDK.post(url: path(postfix)) }
+      end
+
+      actions.each do |action|
+        if action.is_a?(Hash)
+          method_name, postfix_path = action.flatten
+        else
+          method_name = postfix_path = action
+        end
+
+        define_method(method_name) { req.call(self, postfix_path) }
+      end
+    end
+
+    def initialize(hydrated_attrs = {})
+      reload hydrated_attrs
+    end
+
+    def new?
+      !id
+    end
+
+    def refresh!(request = EventbriteSDK)
+      unless new?
+        reload request.get(url: path)
+      else
+        false
+      end
+    end
+
+    def inspect
+      "#<#{self.class}: #{JSON.pretty_generate(@attrs.to_h)}>"
+    end
+
+    def save(postfixed_path = '', request = EventbriteSDK)
+      if changed? || !postfixed_path.empty?
+        response = request.post(url: path(postfixed_path),
+                                payload: attrs.payload(self.class.prefix))
+
+        reload(response)
+
+        true
+      end
+    end
+
+    def to_json(opts = {})
+      attrs.to_json(opts)
+    end
+
+    def delete(request = EventbriteSDK)
+      response = request.delete(url: path)
+      response['deleted']
+    end
+
+    def read_attribute_for_serialization(attribute)
+      attrs[attribute]
+    end
+
+    private
+
+    def resource_class_from_string(klass)
+      EventbriteSDK.const_get(klass)
+    end
+
+    def reload(hydrated_attrs = {})
+      build_attrs(hydrated_attrs)
+    end
+  end
+end

data/lib/eventbrite_sdk/resource/attributes.rb

@@ -0,0 +1,158 @@
+module EventbriteSDK
+  class Resource
+    class Attributes
+      attr_reader :attrs, :changes
+
+      def self.build(attrs, schema)
+        new({}, schema).tap do |instance|
+          instance.assign_attributes(attrs)
+        end
+      end
+
+      def initialize(hydrated_attrs = {}, schema = NullSchemaDefinition.new)
+        @attrs = {}
+        @changes = {}
+        @schema = schema
+
+        # Build out initial hash based on schema's defined keys
+        schema.defined_keys.each { |key| bury_attribute(key, nil) }
+
+        @attrs = attrs.merge(stringify_keys(hydrated_attrs))
+      end
+
+      def [](key)
+        public_send(key)
+      end
+
+      def assign_attributes(new_attrs)
+        stringify_keys(new_attrs).each do |attribute_key, value|
+          assign_value(attribute_key, value) if schema.writeable?(attribute_key)
+        end
+
+        nil
+      end
+
+      def changed?
+        changes.any?
+      end
+
+      def to_h
+        attrs.to_h
+      end
+
+      def to_json(opts = {})
+        to_h.to_json(opts)
+      end
+
+      def inspect
+        "#<#{self.class}: #{JSON.pretty_generate(@attrs.to_h)}>"
+      end
+
+      def reset!
+        changes.each do |attribute_key, (old_value, _current_value)|
+          bury_attribute(attribute_key, old_value)
+        end
+
+        @changes = {}
+
+        true
+      end
+
+      # Provides changeset in a format that can be thrown at an endpoint
+      #
+      # prefix: This is needed due to inconsistencies in the EB API
+      #         Sometimes there's a prefix, sometimes there's not,
+      #         sometimes it's singular, sometimes it's plural.
+      #         Once the API gets a bit more nomalized we can remove this
+      #         alltogether and infer a prefix based
+      #         on the class name of the resource
+      def payload(prefix = nil)
+        changes.each_with_object({}) do |(attribute_key, (_, value)), payload|
+          key = if prefix
+                  "#{prefix}.#{attribute_key}"
+                else
+                  attribute_key
+                end
+
+          bury(key, value, payload)
+        end
+      end
+
+      def values
+        attrs.values
+      end
+
+      private
+
+      attr_reader :schema
+
+      def assign_value(attribute_key, value)
+        dirty_check(attribute_key, value)
+        add_rich_value(attribute_key)
+        bury_attribute(attribute_key, value)
+      end
+
+      def dirty_check(attribute_key, value)
+        initial_value = attrs.dig(*attribute_key.split('.'))
+
+        if initial_value != value
+          changes[attribute_key] = [initial_value, value]
+        end
+      end
+
+      def bury_attribute(attribute_key, value)
+        bury(attribute_key, value, attrs)
+      end
+
+      # Since we use dirty checking to determine what the payload is
+      # you can run into a case where a "rich media" field needs other attrs
+      # Namely timezone, so if a rich date changed, add the tz with it.
+      def add_rich_value(attribute_key)
+        if changes[attribute_key] && attribute_key =~ /\A(.+)\.utc\z/
+          key_prefix = Regexp.last_match(1)
+          tz = attrs.dig(key_prefix, 'timezone')
+
+          changes["#{key_prefix}.timezone"] = [tz, tz]
+        end
+      end
+
+      def bury(attribute_key, value, hash = {})
+        keys = attribute_key.split '.'
+
+        # Hand rolling #bury
+        # hopefully we get it in the next release of Ruby
+        keys.each_cons(2).reduce(hash) do |prev_attrs, (key, _)|
+          prev_attrs[key] ||= {}
+        end[keys.last] = value
+
+        hash
+      end
+
+      def method_missing(method_name, *_args, &_block)
+        requested_key = method_name.to_s
+
+        if attrs.has_key?(requested_key)
+          handle_requested_attr(attrs[requested_key])
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, _include_private = false)
+        attrs.has_key?(method_name.to_s) || super
+      end
+
+      def handle_requested_attr(value)
+        if value.is_a?(Hash)
+          self.class.new(value)
+        else
+          value
+        end
+      end
+
+      def stringify_keys(params)
+        params.to_h.map { |key, value| [key.to_s, value] }.to_h
+      end
+    end
+  end
+end