calendlyr 0.7.4 → 0.10.0

data/lib/calendlyr/error.rb

@@ -1,33 +1,23 @@
 module Calendlyr
   class Error < StandardError; end
 
-  class PermissionDenied < StandardError; end
-
-  class BadRequest < StandardError; end
-
-  class PaymentRequired < StandardError; end
-
-  class Unauthenticated < StandardError; end
-
-  class NotFound < StandardError; end
-
-  class ExternalCalendarError < StandardError; end
-
-  class InternalServerError < StandardError; end
-
-  class TooManyRequests < StandardError; end
+  class PaymentRequired < Error; end
+
+  ERROR_TYPES = {
+    "400" => "BadRequest",
+    "401" => "Unauthenticated",
+    "403" => "PermissionDenied",
+    "404" => "NotFound",
+    "424" => "ExternalCalendarError",
+    "429" => "TooManyRequests",
+    "500" => "InternalServerError"
+  }
+
+  ERROR_TYPES.values.each do |error_class|
+    Calendlyr.const_set(error_class, Class.new(Error))
+  end
 
   class ResponseErrorHandler
-    ERROR_TYPES = {
-      "400" => BadRequest,
-      "401" => Unauthenticated,
-      "403" => PermissionDenied,
-      "404" => NotFound,
-      "424" => ExternalCalendarError,
-      "429" => TooManyRequests,
-      "500" => InternalServerError
-    }
-
     def initialize(code, body)
       @code = code
       @body = body
@@ -44,7 +34,8 @@ module Calendlyr
     def error_type
       return PaymentRequired if @code == "403" && @body["message"].include?("upgrade")
 
-      ERROR_TYPES[@code]
+      klass = "Calendlyr::#{Calendlyr::ERROR_TYPES[@code]}"
+      Calendlyr.const_get(klass)
     end
 
     def too_many_requests_error

data/lib/calendlyr/object.rb

@@ -1,31 +1,94 @@
-require "ostruct"
-
 module Calendlyr
-  class Object < OpenStruct
+  class Object
     def self.get_slug(path)
       path.split("/").last
     end
 
-    def initialize(attributes)
-      super(to_ostruct(attributes.merge(uuid: extract_uuid(attributes))))
+    private_class_method :get_slug
+
+    def initialize(attributes = nil, add_uuid: true, **kwargs)
+      attrs = (attributes || {}).merge(kwargs).dup
+      if add_uuid && !attrs.key?(:uuid) && !attrs.key?("uuid")
+        attrs = attrs.merge(uuid: extract_uuid(attrs))
+      end
+
+      @attributes = attrs.each_with_object({}) do |(key, value), hash|
+        hash[key.to_s] = wrap(value)
+      end
     end
 
-    def to_ostruct(obj)
-      if obj.is_a?(Hash)
-        OpenStruct.new(obj.map { |key, val| [key, to_ostruct(val)] }.to_h)
-      elsif obj.is_a?(Array)
-        obj.map { |o| to_ostruct(o) }
-      else # Assumed to be a primitive value
-        obj
+    def method_missing(name, *args, &block)
+      if args.empty? && block.nil?
+        return @attributes[name.to_s] if @attributes.key?(name.to_s)
+
+        return nil
       end
+
+      super
     end
 
+    def respond_to_missing?(name, include_private = false)
+      @attributes.key?(name.to_s) || super
+    end
+
+    def to_h
+      @attributes.each_with_object({}) do |(key, value), hash|
+        hash[key.to_sym] = unwrap(value)
+      end
+    end
+
+    def inspect
+      attributes = @attributes.map do |key, value|
+        "#{key}=#{value.inspect}"
+      end.join(" ")
+      "#<#{self.class} #{attributes}>"
+    end
+
+    def ==(other)
+      other.is_a?(self.class) && to_h == other.to_h
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      to_h.hash
+    end
+
+    private
+
     def extract_uuid(attrs)
-      attrs["uri"] ? get_slug(attrs["uri"]) : nil
+      uri = attrs["uri"] || attrs[:uri]
+      uri ? get_slug(uri) : nil
     end
 
+    protected
+
     def get_slug(path)
-      Calendlyr::Object.get_slug(path)
+      self.class.send(:get_slug, path)
+    end
+
+    private
+
+    def wrap(value)
+      if value.is_a?(Hash)
+        self.class.new(value, add_uuid: false)
+      elsif value.is_a?(Array)
+        value.map { |item| wrap(item) }
+      else
+        value
+      end
+    end
+
+    def unwrap(value)
+      if value.is_a?(self.class)
+        value.to_h
+      elsif value.is_a?(Array)
+        value.map { |item| unwrap(item) }
+      else
+        value
+      end
     end
   end
 end

data/lib/calendlyr/objects/event_type.rb

@@ -7,9 +7,5 @@ module Calendlyr
     def create_share(**params)
       client.shares.create(**params.merge(event_type: uri))
     end
-
-    def available_times(start_time:, end_time:, **params)
-      client.event_types.list_available_times(**params.merge(event_type: uri, start_time: start_time, end_time: end_time))
-    end
   end
 end

data/lib/calendlyr/objects/event_types/availability_schedule.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Calendlyr
+  module EventTypes
+    class AvailabilitySchedule < Object
+    end
+  end
+end

data/lib/calendlyr/objects/events/invitee.rb

@@ -1,7 +1,7 @@
 module Calendlyr
   class Events::Invitee < Object
     def cancel(reason: nil)
-      client.events.cancel(uuid: uuid, reason: reason)
+      client.events.cancel(uuid: get_slug(event), reason: reason)
     end
 
     def create_no_shows

data/lib/calendlyr/objects/location.rb

@@ -0,0 +1,4 @@
+module Calendlyr
+  class Location < Object
+  end
+end

data/lib/calendlyr/objects/organization.rb

@@ -43,10 +43,6 @@ module Calendlyr
       client.webhooks.create(**params.merge(organization: uri, url: url, events: events, scope: scope))
     end
 
-    def sample_webhook_data(event:, scope:, **params)
-      client.webhooks.sample_webhook_data(event: event, scope: scope, organization: uri, **params)
-    end
-
     # Invitations
     def invite_user(email:, **params)
       client.organizations.invite(**params.merge(organization_uuid: uuid, email: email))

data/lib/calendlyr/objects/share.rb

@@ -1,9 +1,4 @@
 module Calendlyr
   class Share < Object
-    def associated_scheduling_links
-      scheduling_links.map do |scheduling_link|
-        SchedulingLink.new(scheduling_link.to_h.merge(client: client))
-      end
-    end
   end
 end

data/lib/calendlyr/resource.rb

@@ -8,6 +8,8 @@ module Calendlyr
     attr_reader :client
 
     ERROR_CODES = %w[400 401 403 404 424 429 500]
+    MAX_RETRIES = 3
+    RETRY_BACKOFF = [1, 2, 4]
 
     def initialize(client)
       @client = client
@@ -23,6 +25,14 @@ module Calendlyr
       handle_response request(url, Net::HTTP::Post, body: body)
     end
 
+    def patch_request(url, body:)
+      handle_response request(url, Net::HTTP::Patch, body: body)
+    end
+
+    def put_request(url, body:)
+      handle_response request(url, Net::HTTP::Put, body: body)
+    end
+
     def delete_request(url, params: {})
       handle_response request(url, Net::HTTP::Delete, params: params)
     end
@@ -37,30 +47,47 @@ module Calendlyr
 
       http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = true
-      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      http.open_timeout = client.open_timeout
+      http.read_timeout = client.read_timeout
 
       request = req_type.new(uri)
       request["Content-Type"] = "application/json"
       request["Authorization"] = "Bearer #{client.token}"
       request.body = body.to_json if body.any?
 
-      http.request(request)
+      attempts = 0
+
+      loop do
+        response = http.request(request)
+        return response unless response.code == "429"
+        return response if attempts >= MAX_RETRIES
+
+        sleep retry_after_seconds(response, attempts)
+        attempts += 1
+      end
     end
 
     def handle_response(response)
-      return true unless response.read_body
+      body_string = response.body.to_s
 
       body = begin
-        JSON.parse(response.read_body)
-      rescue
+        body_string.empty? ? {} : JSON.parse(body_string)
+      rescue JSON::ParserError
         {}
       end
 
       if ERROR_CODES.include? response.code
         raise ResponseErrorHandler.new(response.code, body).error
-      else
-        body
       end
+
+      body
+    end
+
+    def retry_after_seconds(response, attempt)
+      retry_after = response["Retry-After"]
+      return retry_after.to_i if retry_after&.match?(/^\d+$/)
+
+      RETRY_BACKOFF.fetch(attempt)
     end
   end
 end

data/lib/calendlyr/resources/event_types.rb

@@ -0,0 +1,37 @@
+module Calendlyr
+  class EventTypesResource < Resource
+    def list(**params)
+      response = get_request("event_types", params: params)
+      Collection.from_response(response, type: EventType, client: client)
+    end
+
+    def retrieve(uuid:)
+      EventType.new get_request("event_types/#{uuid}").dig("resource").merge(client: client)
+    end
+
+    def create_one_off(name:, host:, duration:, date_setting:, location:, **params)
+      body = {name: name, host: host, duration: duration, date_setting: date_setting, location: location}.merge(params)
+      EventType.new post_request("one_off_event_types", body: body).dig("resource").merge(client: client)
+    end
+
+    def create(name:, duration:, pooling_type:, **params)
+      body = {name: name, duration: duration, pooling_type: pooling_type}.merge(params)
+      EventType.new post_request("event_types", body: body).dig("resource").merge(client: client)
+    end
+
+    def update(uuid:, **params)
+      EventType.new patch_request("event_types/#{uuid}", body: params).dig("resource").merge(client: client)
+    end
+
+    # Availability Schedules
+    def list_availability_schedules(event_type_uuid:, **params)
+      response = get_request("event_type_availability_schedules", params: {event_type_uuid: event_type_uuid}.merge(params))
+      Collection.from_response(response, type: EventTypes::AvailabilitySchedule, client: client)
+    end
+
+    def update_availability_schedule(event_type_uuid:, availability_schedules:, **params)
+      body = {event_type_uuid: event_type_uuid, availability_schedules: availability_schedules}.merge(params)
+      patch_request("event_type_availability_schedules", body: body)
+    end
+  end
+end

data/lib/calendlyr/resources/{event.rb → events.rb}

@@ -1,5 +1,5 @@
 module Calendlyr
-  class EventResource < Resource
+  class EventsResource < Resource
     def list(**params)
       response = get_request("scheduled_events", params: params)
       Collection.from_response(response, type: Event, client: client)
@@ -23,6 +23,11 @@ module Calendlyr
       Events::Invitee.new get_request("scheduled_events/#{event_uuid}/invitees/#{invitee_uuid}").dig("resource").merge(client: client)
     end
 
+    def create_invitee(event_type:, start_time:, invitee:, **params)
+      body = {event_type: event_type, start_time: start_time, invitee: invitee}.merge(params)
+      Events::Invitee.new post_request("invitees", body: body).dig("invitee").merge(client: client)
+    end
+
     # Invitee No Show
     def retrieve_invitee_no_show(uuid:)
       Events::InviteeNoShow.new get_request("invitee_no_shows/#{uuid}").dig("resource").merge(client: client)

data/lib/calendlyr/resources/{group.rb → groups.rb}

@@ -1,5 +1,5 @@
 module Calendlyr
-  class GroupResource < Resource
+  class GroupsResource < Resource
     def list(organization:, **params)
       response = get_request("groups", params: params.merge(organization: organization))
       Collection.from_response(response, type: Group, client: client)

data/lib/calendlyr/resources/locations.rb

@@ -0,0 +1,8 @@
+module Calendlyr
+  class LocationsResource < Resource
+    def list(**params)
+      response = get_request("locations", params: params)
+      Collection.from_response(response, type: Location, client: client)
+    end
+  end
+end

data/lib/calendlyr/resources/{organization.rb → organizations.rb}

@@ -1,5 +1,5 @@
 module Calendlyr
-  class OrganizationResource < Resource
+  class OrganizationsResource < Resource
     def activity_log(organization: nil, **params)
       response = get_request("activity_log_entries", params: {organization: organization}.merge(params).compact)
       Collection.from_response(response, type: ActivityLog, client: client)

data/lib/calendlyr/resources/{routing_form.rb → routing_forms.rb}

@@ -1,5 +1,5 @@
 module Calendlyr
-  class RoutingFormResource < Resource
+  class RoutingFormsResource < Resource
     def list(organization:, **params)
       response = get_request("routing_forms", params: {organization: organization}.merge(params))
       Collection.from_response(response, type: RoutingForm, client: client)

data/lib/calendlyr/resources/{share.rb → shares.rb}

@@ -1,5 +1,5 @@
 module Calendlyr
-  class ShareResource < Resource
+  class SharesResource < Resource
     def create(event_type:, **params)
       body = {event_type: event_type}.merge(params)
       Share.new post_request("shares", body: body).dig("resource").merge(client: client)

data/lib/calendlyr/resources/{user.rb → users.rb}

@@ -1,5 +1,5 @@
 module Calendlyr
-  class UserResource < Resource
+  class UsersResource < Resource
     def me
       retrieve(uuid: "me")
     end

data/lib/calendlyr/resources/{webhook.rb → webhooks.rb}

@@ -1,5 +1,5 @@
 module Calendlyr
-  class WebhookResource < Resource
+  class WebhooksResource < Resource
     def list(organization:, scope:, **params)
       response = get_request("webhook_subscriptions", params: params.merge(organization: organization, scope: scope).compact)
       Collection.from_response(response, type: Webhooks::Subscription, client: client)
@@ -17,9 +17,5 @@ module Calendlyr
     def delete(webhook_uuid:)
       delete_request("webhook_subscriptions/#{webhook_uuid}")
     end
-
-    def sample_webhook_data(event:, organization:, scope:, **params)
-      Object.new get_request("sample_webhook_data", params: params.merge(event: event, organization: organization, scope: scope)).merge(client: client)
-    end
   end
 end

data/lib/calendlyr/version.rb

@@ -1,3 +1,3 @@
 module Calendlyr
-  VERSION = "0.7.4"
+  VERSION = "0.10.0"
 end

data/lib/calendlyr.rb

@@ -7,29 +7,30 @@ module Calendlyr
   autoload :Resource, "calendlyr/resource"
 
   # Errors
+  autoload :ERROR_TYPES, "calendlyr/error"
   autoload :BadRequest, "calendlyr/error"
   autoload :Error, "calendlyr/error"
-  autoload :ExternalCalendarEror, "calendlyr/error"
+  autoload :ExternalCalendarError, "calendlyr/error"
   autoload :InternalServerError, "calendlyr/error"
   autoload :NotFound, "calendlyr/error"
   autoload :PaymentRequired, "calendlyr/error"
   autoload :PermissionDenied, "calendlyr/error"
-  autoload :ResponseErrorHandler, "calendlyr/error"
   autoload :Unauthenticated, "calendlyr/error"
+  autoload :TooManyRequests, "calendlyr/error"
+  autoload :ResponseErrorHandler, "calendlyr/error"
 
   # High-level categories of Calendly API calls
   autoload :AvailabilityResource, "calendlyr/resources/availability"
   autoload :DataComplianceResource, "calendlyr/resources/data_compliance"
-  autoload :EventResource, "calendlyr/resources/event"
-  autoload :EventTypeResource, "calendlyr/resources/event_type"
-  autoload :GroupResource, "calendlyr/resources/group"
-  autoload :OrganizationResource, "calendlyr/resources/organization"
-  autoload :OutgoingCommunicationResource, "calendlyr/resources/outgoing_communication"
-  autoload :RoutingFormResource, "calendlyr/resources/routing_form"
-  autoload :SchedulingLinkResource, "calendlyr/resources/scheduling_link"
-  autoload :ShareResource, "calendlyr/resources/share"
-  autoload :UserResource, "calendlyr/resources/user"
-  autoload :WebhookResource, "calendlyr/resources/webhook"
+  autoload :EventsResource, "calendlyr/resources/events"
+  autoload :EventTypesResource, "calendlyr/resources/event_types"
+  autoload :GroupsResource, "calendlyr/resources/groups"
+  autoload :OrganizationsResource, "calendlyr/resources/organizations"
+  autoload :LocationsResource, "calendlyr/resources/locations"
+  autoload :RoutingFormsResource, "calendlyr/resources/routing_forms"
+  autoload :SharesResource, "calendlyr/resources/shares"
+  autoload :UsersResource, "calendlyr/resources/users"
+  autoload :WebhooksResource, "calendlyr/resources/webhooks"
 
   # Classes used to return a nicer object wrapping the response data
   autoload :ActivityLog, "calendlyr/objects/activity_log"
@@ -37,8 +38,8 @@ module Calendlyr
   autoload :EventType, "calendlyr/objects/event_type"
   autoload :Group, "calendlyr/objects/group"
   autoload :Organization, "calendlyr/objects/organization"
+  autoload :Location, "calendlyr/objects/location"
   autoload :RoutingForm, "calendlyr/objects/routing_form"
-  autoload :SchedulingLink, "calendlyr/objects/scheduling_link"
   autoload :Share, "calendlyr/objects/share"
   autoload :User, "calendlyr/objects/user"
 
@@ -56,8 +57,7 @@ module Calendlyr
   end
 
   module EventTypes
-    autoload :AvailableTime, "calendlyr/objects/event_types/available_time"
-    autoload :Membership, "calendlyr/objects/event_types/membership"
+    autoload :AvailabilitySchedule, "calendlyr/objects/event_types/availability_schedule"
     autoload :Profile, "calendlyr/objects/event_types/profile"
   end
 

data/test/calendlyr/client_test.rb

@@ -8,4 +8,29 @@ class ClientTest < Minitest::Test
   def test_inspect
     assert_equal "#<Calendlyr::Client>", client.inspect
   end
+
+  def test_method_missing
+    assert_raises NoMethodError do
+      client.useers
+    end
+  end
+
+  def test_respond_to_missing?
+    assert client.respond_to?(:users)
+    refute client.respond_to?(:useers)
+  end
+
+  def test_default_timeouts
+    new_client = Calendlyr::Client.new(token: "fake")
+
+    assert_equal 30, new_client.open_timeout
+    assert_equal 30, new_client.read_timeout
+  end
+
+  def test_custom_timeouts
+    new_client = Calendlyr::Client.new(token: "fake", open_timeout: 10, read_timeout: 15)
+
+    assert_equal 10, new_client.open_timeout
+    assert_equal 15, new_client.read_timeout
+  end
 end

data/test/calendlyr/collection_test.rb

@@ -0,0 +1,64 @@
+require "test_helper"
+
+class CollectionTest < Minitest::Test
+  def build_collection
+    data = [
+      Calendlyr::Object.new(name: "Alice"),
+      Calendlyr::Object.new(name: "Bob")
+    ]
+
+    Calendlyr::Collection.new(data: data, count: 2, next_page: nil, client: client)
+  end
+
+  def test_each_yields_items
+    collection = build_collection
+    names = []
+
+    collection.each do |item|
+      names << item.name
+    end
+
+    assert_equal %w[Alice Bob], names
+  end
+
+  def test_map_is_available_from_enumerable
+    collection = build_collection
+
+    assert_equal %w[Alice Bob], collection.map(&:name)
+  end
+
+  def test_collection_responds_to_select
+    collection = build_collection
+
+    assert collection.respond_to?(:select)
+  end
+
+  def test_count_without_block_returns_metadata_count
+    collection = Calendlyr::Collection.new(
+      data: [Calendlyr::Object.new(name: "Alice")],
+      count: 10,
+      next_page: nil,
+      client: client
+    )
+
+    assert_equal 10, collection.count
+  end
+
+  def test_count_with_block_uses_enumerable_count
+    collection = build_collection
+
+    assert_equal(1, collection.count { |item| item.name == "Alice" })
+  end
+
+  def test_count_with_argument_uses_enumerable_count
+    alice = Calendlyr::Object.new(name: "Alice")
+    collection = Calendlyr::Collection.new(
+      data: [alice, Calendlyr::Object.new(name: "Bob")],
+      count: 10,
+      next_page: nil,
+      client: client
+    )
+
+    assert_equal 1, collection.count(alice)
+  end
+end

data/test/calendlyr/object_test.rb

@@ -15,7 +15,38 @@ class ObjectTest < Minitest::Test
 
   def test_array
     object = Calendlyr::Object.new(foo: [{bar: :baz}], client: nil)
-    assert_equal OpenStruct, object.foo.first.class
+    assert_equal Calendlyr::Object, object.foo.first.class
     assert_equal :baz, object.foo.first.bar
   end
+
+  def test_uuid_extraction_from_string_uri
+    object = Calendlyr::Object.new("uri" => "https://api.calendly.com/users/ABC123")
+
+    assert_equal "ABC123", object.uuid
+  end
+
+  def test_missing_attribute_returns_nil
+    object = Calendlyr::Object.new(name: "test")
+
+    assert_nil object.nonexistent
+  end
+
+  def test_respond_to_existing_attribute
+    object = Calendlyr::Object.new(name: "test")
+
+    assert object.respond_to?(:name)
+  end
+
+  def test_to_h_returns_deep_hash
+    object = Calendlyr::Object.new("profile" => {"age" => 30, "items" => [{"id" => 1}]})
+
+    assert_equal({profile: {age: 30, items: [{id: 1}]}, uuid: nil}, object.to_h)
+  end
+
+  def test_equals_other_object_with_same_attributes
+    first = Calendlyr::Object.new(name: "test")
+    second = Calendlyr::Object.new(name: "test")
+
+    assert_equal first, second
+  end
 end

data/test/calendlyr/objects/event_type_test.rb

@@ -7,13 +7,6 @@ class EventTypeObjectTest < Minitest::Test
     json = JSON.parse(fixture_file("objects/event_type")).merge(client: client)
     @event_type = Calendlyr::EventType.new(json)
 
-    event_type_uri = "https://api.calendly.com/event_types/AAAAAAAAAAAAAAAA"
-    @start_time = "2020-01-02T20:00:00.000000Z"
-    @end_time = "2020-01-07T24:00:00.000000Z"
-
-    response = {body: fixture_file("event_type_available_times/list"), status: 200}
-    stub(path: "event_type_available_times?event_type=#{event_type_uri}&start_time=#{@start_time}&end_time=#{@end_time}", response: response)
-
     event_type_uri = "https://api.calendly.com/event_types/AAAAAAAAAAAAAAAA"
     response = {body: fixture_file("shares/create"), status: 201}
     stub(method: :post, path: "shares", body: {event_type: event_type_uri}, response: response)
@@ -32,12 +25,4 @@ class EventTypeObjectTest < Minitest::Test
     assert_instance_of Calendlyr::Share, share
     assert_equal 1, share.scheduling_links.size
   end
-
-  def test_available_times
-    available_times = @event_type.available_times(start_time: @start_time, end_time: @end_time)
-
-    assert 3, available_times.data.size
-    assert "available", available_times.data.first.status
-    assert_instance_of Calendlyr::EventTypes::AvailableTime, available_times.data.first
-  end
 end