calendlyr 0.7.5 → 0.10.0

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

@@ -14,15 +14,24 @@ module Calendlyr
       EventType.new post_request("one_off_event_types", body: body).dig("resource").merge(client: client)
     end
 
-    def list_memberships(event_type:, **params)
-      response = get_request("event_type_memberships", params: {event_type: event_type}.merge(params))
-      Collection.from_response(response, type: EventTypes::Membership, client: client)
+    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
 
-    # Available Times
-    def list_available_times(event_type:, start_time:, end_time:, **params)
-      response = get_request("event_type_available_times", params: {event_type: event_type, start_time: start_time, end_time: end_time}.merge(params))
-      Collection.from_response(response, type: EventTypes::AvailableTime, client: client)
+    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/events.rb

@@ -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/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/webhooks.rb

@@ -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.5"
+  VERSION = "0.10.0"
 end

data/lib/calendlyr.rb

@@ -7,6 +7,7 @@ module Calendlyr
   autoload :Resource, "calendlyr/resource"
 
   # Errors
+  autoload :ERROR_TYPES, "calendlyr/error"
   autoload :BadRequest, "calendlyr/error"
   autoload :Error, "calendlyr/error"
   autoload :ExternalCalendarError, "calendlyr/error"
@@ -25,9 +26,8 @@ module Calendlyr
   autoload :EventTypesResource, "calendlyr/resources/event_types"
   autoload :GroupsResource, "calendlyr/resources/groups"
   autoload :OrganizationsResource, "calendlyr/resources/organizations"
-  autoload :OutgoingCommunicationsResource, "calendlyr/resources/outgoing_communications"
+  autoload :LocationsResource, "calendlyr/resources/locations"
   autoload :RoutingFormsResource, "calendlyr/resources/routing_forms"
-  autoload :SchedulingLinksResource, "calendlyr/resources/scheduling_links"
   autoload :SharesResource, "calendlyr/resources/shares"
   autoload :UsersResource, "calendlyr/resources/users"
   autoload :WebhooksResource, "calendlyr/resources/webhooks"
@@ -38,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"
 
@@ -57,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

@@ -19,4 +19,18 @@ class ClientTest < Minitest::Test
     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

data/test/calendlyr/objects/event_types/availability_schedule_test.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module EventTypes
+  class AvailabilityScheduleObjectTest < Minitest::Test
+    def setup
+      json = JSON.parse(fixture_file("objects/event_types/availability_schedule")).merge(client: client)
+      @availability_schedule = Calendlyr::EventTypes::AvailabilitySchedule.new(json)
+    end
+
+    def test_uri
+      assert_equal "https://api.calendly.com/event_type_availability_schedules/AAAAAAAAAAAAAAAA", @availability_schedule.uri
+    end
+
+    def test_event_type
+      assert_equal "https://api.calendly.com/event_types/BBBBBBBBBBBBBBBB", @availability_schedule.event_type
+    end
+  end
+end

data/test/calendlyr/objects/events/cancellation_test.rb

@@ -10,7 +10,7 @@ module Events
     end
 
     def test_canceled_by
-      assert "string", @cancellation.canceled_by
+      assert_equal "string", @cancellation.canceled_by
     end
   end
 end

data/test/calendlyr/objects/events/guest_test.rb

@@ -10,7 +10,7 @@ module Events
     end
 
     def test_email
-      assert "user@example.com", @guest.email
+      assert_equal "user@example.com", @guest.email
     end
   end
 end

data/test/calendlyr/objects/events/invitee_no_show_test.rb

@@ -10,7 +10,7 @@ module Events
     end
 
     def test_created_at
-      assert "2019-01-02T03:04:05.678123Z", @invitee_no_show.created_at
+      assert_equal "2019-01-02T03:04:05.678123Z", @invitee_no_show.created_at
     end
 
     def test_delete

data/test/calendlyr/objects/events/invitee_test.rb

@@ -10,14 +10,21 @@ module Events
     end
 
     def test_email
-      assert "user@example.com", @invitee.email
+      assert_equal "test@example.com", @invitee.email
     end
 
     def test_cancel
+      invitee = Calendlyr::Events::Invitee.new(
+        JSON.parse(fixture_file("objects/events/invitee")).merge(
+          "event" => "https://api.calendly.com/scheduled_events/EVT123",
+          "uri" => "https://api.calendly.com/scheduled_events/EVT123/invitees/INV456",
+          :client => client
+        )
+      )
       response = {body: fixture_file("events/cancel_invitee"), status: 201}
-      stub(method: :post, path: "scheduled_events/#{@invitee.uuid}/cancellation", response: response)
+      stub(method: :post, path: "scheduled_events/EVT123/cancellation", response: response)
 
-      cancellation = @invitee.cancel(reason: "I'm busy")
+      cancellation = invitee.cancel(reason: "I'm busy")
 
       assert_instance_of Calendlyr::Events::Cancellation, cancellation
       assert_equal "host", cancellation.canceler_type

data/test/calendlyr/objects/location_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class LocationObjectTest < Minitest::Test
+  def setup
+    json = JSON.parse(fixture_file("objects/location")).merge(client: client)
+    @location = Calendlyr::Location.new(json)
+  end
+
+  def test_uri
+    assert_equal "https://api.calendly.com/locations/AAAAAAAAAAAAAAAA", @location.uri
+  end
+
+  def test_type
+    assert_equal "zoom", @location.type
+  end
+
+  def test_display_name
+    assert_equal "Zoom", @location.display_name
+  end
+end

data/test/calendlyr/objects/organization_test.rb

@@ -111,14 +111,6 @@ class OrganizatonObjectTest < Minitest::Test
     assert @organization.create_webhook(**body)
   end
 
-  def test_sample_webhook_data
-    stub(path: "sample_webhook_data?event=invitee.created&scope=organization&organization=https://api.calendly.com/organizations/012345678901234567890", response: {body: fixture_file("webhooks/sample"), status: 200})
-    webhook_data = @organization.sample_webhook_data(event: "invitee.created", scope: "organization")
-
-    assert_instance_of Calendlyr::Object, webhook_data
-    assert_equal "invitee.created", webhook_data.event
-  end
-
   def test_invite_user
     email = "email@example.com"
     response = {body: fixture_file("organizations/invite"), status: 201}

data/test/calendlyr/objects/organizations/invitation_test.rb

@@ -12,7 +12,7 @@ module Organizations
       stub(method: :delete, path: "organizations/#{@invitation.associated_organization.uuid}/invitations/#{@invitation.uuid}", response: response)
 
       response = {body: fixture_file("users/retrieve"), status: 200}
-      stub(path: "users/#{Calendlyr::Object.get_slug(@invitation.user)}", response: response)
+      stub(path: "users/#{@invitation.user.split("/").last}", response: response)
     end
 
     def test_associated_organization

data/test/calendlyr/objects/share_test.rb

@@ -3,17 +3,11 @@
 require "test_helper"
 
 class ShareObjectTest < Minitest::Test
-  def test_associated_scheduling_links
+  def test_share
     json = JSON.parse(fixture_file("objects/share")).merge(client: client)
     @share = Calendlyr::Share.new(json)
 
-    response = {body: fixture_file("event_types/retrieve"), status: 200}
-    stub(path: "event_types/AAAAAAAAAAAAAAAA", response: response)
-
-    scheculing_links = @share.associated_scheduling_links
-
-    assert_equal 1, scheculing_links.size
-    assert_equal Calendlyr::SchedulingLink, scheculing_links.first.class
-    assert_equal Calendlyr::EventType, scheculing_links.first.event_type.class
+    assert_instance_of Calendlyr::Share, @share
+    assert_equal 1, @share.scheduling_links.size
   end
 end