calendlyr 0.6.0 → 0.7.0

data/lib/calendlyr/objects/share.rb

@@ -0,0 +1,9 @@
+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/objects/user.rb

@@ -0,0 +1,31 @@
+module Calendlyr
+  class User < Object
+    def organization
+      Organization.new({"uri" => current_organization}.merge(client: client))
+    end
+
+    def availability_schedules(**params)
+      client.availability.list_user_schedules(**params.merge(user: uri))
+    end
+
+    def event_types(**params)
+      client.event_types.list(**params.merge(user: uri))
+    end
+
+    def events(**params)
+      client.events.list(**params.merge(user: uri, organization: current_organization))
+    end
+
+    def membership(uuid:)
+      organization.membership(uuid: uuid)
+    end
+
+    def memberships(**params)
+      organization.memberships(**params.merge(user: uri))
+    end
+
+    def busy_times(start_time:, end_time:, **params)
+      client.availability.list_user_busy_times(**params.merge(user: uri, start_time: start_time, end_time: end_time))
+    end
+  end
+end

data/lib/calendlyr/objects/webhooks/invitee_payload.rb

@@ -0,0 +1,15 @@
+module Calendlyr
+  class Webhooks::InviteePayload < Object
+    def associated_event
+      client.events.retrieve(uuid: get_slug(event))
+    end
+
+    def associated_routing_form_submission
+      client.routing_forms.retrieve_submission(uuid: get_slug(routing_form_submission))
+    end
+
+    def associated_invitee_no_show
+      client.events.retrieve_invitee_no_show(uuid: get_slug(no_show.uri))
+    end
+  end
+end

data/lib/calendlyr/objects/webhooks/payload.rb

@@ -0,0 +1,4 @@
+module Calendlyr
+  class Webhooks::Payload < Object
+  end
+end

data/lib/calendlyr/objects/webhooks/subscription.rb

@@ -0,0 +1,23 @@
+module Calendlyr
+  class Webhooks::Subscription < Object
+    def associated_organization
+      Organization.new({"uri" => organization}.merge(client: client))
+    end
+
+    def associated_user
+      client.users.retrieve(uuid: get_slug(user))
+    end
+
+    def associated_creator
+      client.users.retrieve(uuid: get_slug(creator))
+    end
+
+    def active?
+      state == "active"
+    end
+
+    def disabled?
+      state == "disabled"
+    end
+  end
+end

data/lib/calendlyr/resource.rb

@@ -7,7 +7,7 @@ module Calendlyr
   class Resource
     attr_reader :client
 
-    ERROR_CODES = %w[400 401 403 404 409 500]
+    ERROR_CODES = %w[400 401 403 404 424 500]
 
     def initialize(client)
       @client = client
@@ -52,7 +52,7 @@ module Calendlyr
 
       body = JSON.parse(response.read_body)
       if ERROR_CODES.include? response.code
-        raise Error, "[Error #{response.code}] #{body["title"]}. #{body["message"]}"
+        raise ResponseErrorHandler.new(response.code, body).error
       else
         body
       end

data/lib/calendlyr/resources/availability.rb

@@ -0,0 +1,19 @@
+module Calendlyr
+  class AvailabilityResource < Resource
+    # User Busy Time
+    def list_user_busy_times(user:, start_time:, end_time:, **params)
+      response = get_request("user_busy_times", params: {user: user, start_time: start_time, end_time: end_time}.merge(params).compact)
+      Collection.from_response(response, type: Availabilities::UserBusyTime, client: client)
+    end
+
+    # User Schedule
+    def list_user_schedules(user:, **params)
+      response = get_request("user_availability_schedules", params: {user: user}.merge(params).compact)
+      Collection.from_response(response, type: Availabilities::UserSchedule, client: client)
+    end
+
+    def retrieve_user_schedule(uuid:)
+      Availabilities::UserSchedule.new get_request("user_availability_schedules/#{uuid}").dig("resource").merge(client: client)
+    end
+  end
+end

data/lib/calendlyr/resources/data_compliance.rb

@@ -3,5 +3,9 @@ module Calendlyr
     def delete_invitee_data(emails:)
       post_request("data_compliance/deletion/invitees", body: {emails: emails})
     end
+
+    def delete_scheduled_event_data(start_time:, end_time:)
+      post_request("data_compliance/deletion/events", body: {start_time: start_time, end_time: end_time})
+    end
   end
 end

data/lib/calendlyr/resources/event.rb

@@ -0,0 +1,40 @@
+module Calendlyr
+  class EventResource < Resource
+    def list(**params)
+      response = get_request("scheduled_events", params: params)
+      Collection.from_response(response, type: Event, client: client)
+    end
+
+    def retrieve(uuid:)
+      Event.new get_request("scheduled_events/#{uuid}").dig("resource").merge(client: client)
+    end
+
+    def cancel(uuid:, reason: nil)
+      Events::Cancellation.new post_request("scheduled_events/#{uuid}/cancellation", body: {reason: reason}).dig("resource").merge(client: client)
+    end
+
+    # Invitee
+    def list_invitees(uuid:, **params)
+      response = get_request("scheduled_events/#{uuid}/invitees", params: params)
+      Collection.from_response(response, type: Events::Invitee, client: client)
+    end
+
+    def retrieve_invitee(event_uuid:, invitee_uuid:)
+      Events::Invitee.new get_request("scheduled_events/#{event_uuid}/invitees/#{invitee_uuid}").dig("resource").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)
+    end
+
+    def create_invitee_no_show(invitee:)
+      body = {invitee: invitee}
+      Events::InviteeNoShow.new post_request("invitee_no_shows", body: body).dig("resource").merge(client: client)
+    end
+
+    def delete_invitee_no_show(uuid:)
+      delete_request("invitee_no_shows/#{uuid}")
+    end
+  end
+end

data/lib/calendlyr/resources/event_type.rb

@@ -0,0 +1,28 @@
+module Calendlyr
+  class EventTypeResource < 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 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)
+    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)
+    end
+  end
+end

data/lib/calendlyr/resources/group.rb

@@ -0,0 +1,22 @@
+module Calendlyr
+  class GroupResource < Resource
+    def list(organization:, **params)
+      response = get_request("groups", params: params.merge(organization: organization))
+      Collection.from_response(response, type: Group, client: client)
+    end
+
+    def retrieve(uuid:)
+      Group.new get_request("groups/#{uuid}").dig("resource").merge(client: client)
+    end
+
+    # Relationships
+    def list_relationships(**params)
+      response = get_request("group_relationships", params: params)
+      Collection.from_response(response, type: Groups::Relationship, client: client)
+    end
+
+    def retrieve_relationship(uuid:)
+      Groups::Relationship.new get_request("group_relationships/#{uuid}").dig("resource").merge(client: client)
+    end
+  end
+end

data/lib/calendlyr/resources/organization.rb

@@ -0,0 +1,40 @@
+module Calendlyr
+  class OrganizationResource < 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)
+    end
+
+    # Memberships
+    def list_memberships(**params)
+      response = get_request("organization_memberships", params: params)
+      Collection.from_response(response, type: Organizations::Membership, client: client)
+    end
+
+    def retrieve_membership(uuid:)
+      Organizations::Membership.new(get_request("organization_memberships/#{uuid}").dig("resource").merge(client: client))
+    end
+
+    def remove_user(uuid:)
+      delete_request("organization_memberships/#{uuid}")
+    end
+
+    # Invitations
+    def list_invitations(uuid:, **params)
+      response = get_request("organizations/#{uuid}/invitations", params: params)
+      Collection.from_response(response, type: Organizations::Invitation, client: client)
+    end
+
+    def retrieve_invitation(org_uuid:, uuid:)
+      Organizations::Invitation.new get_request("organizations/#{org_uuid}/invitations/#{uuid}").dig("resource").merge(client: client)
+    end
+
+    def invite(organization_uuid:, email:)
+      Organizations::Invitation.new post_request("organizations/#{organization_uuid}/invitations", body: {email: email}).dig("resource").merge(client: client)
+    end
+
+    def revoke_invitation(org_uuid:, uuid:)
+      delete_request("organizations/#{org_uuid}/invitations/#{uuid}")
+    end
+  end
+end

data/lib/calendlyr/resources/outgoing_communication.rb

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

data/lib/calendlyr/resources/routing_form.rb

@@ -0,0 +1,22 @@
+module Calendlyr
+  class RoutingFormResource < Resource
+    def list(organization:, **params)
+      response = get_request("routing_forms", params: {organization: organization}.merge(params))
+      Collection.from_response(response, type: RoutingForm, client: client)
+    end
+
+    def retrieve(uuid:)
+      RoutingForm.new(get_request("routing_forms/#{uuid}").dig("resource").merge(client: client))
+    end
+
+    # Routing Form Submission
+    def list_submissions(form:, **params)
+      response = get_request("routing_form_submissions", params: {form: form}.merge(params))
+      Collection.from_response(response, type: RoutingForms::Submission, client: client)
+    end
+
+    def retrieve_submission(uuid:)
+      RoutingForms::Submission.new get_request("routing_form_submissions/#{uuid}").dig("resource").merge(client: client)
+    end
+  end
+end

data/lib/calendlyr/resources/{scheduling_links.rb → scheduling_link.rb}

@@ -1,7 +1,7 @@
 module Calendlyr
   class SchedulingLinkResource < Resource
-    def create(owner_uri:, max_event_count:, owner_type: "EventType")
-      body = {owner: owner_uri, max_event_count: max_event_count, owner_type: owner_type}
+    def create(owner:, max_event_count:, owner_type: "EventType")
+      body = {owner: owner, max_event_count: max_event_count, owner_type: owner_type}
       SchedulingLink.new post_request("scheduling_links", body: body).dig("resource").merge(client: client)
     end
   end

data/lib/calendlyr/resources/share.rb

@@ -0,0 +1,8 @@
+module Calendlyr
+  class ShareResource < 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)
+    end
+  end
+end

data/lib/calendlyr/resources/user.rb

@@ -0,0 +1,11 @@
+module Calendlyr
+  class UserResource < Resource
+    def me
+      retrieve(uuid: "me")
+    end
+
+    def retrieve(uuid:)
+      User.new get_request("users/#{uuid}").dig("resource").merge(client: client)
+    end
+  end
+end

data/lib/calendlyr/resources/webhook.rb

@@ -0,0 +1,25 @@
+module Calendlyr
+  class WebhookResource < 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)
+    end
+
+    def create(url:, events:, organization:, scope:, **params)
+      body = params.merge(url: url, events: events, organization: organization, scope: scope)
+      Webhooks::Subscription.new post_request("webhook_subscriptions", body: body).dig("resource").merge(client: client)
+    end
+
+    def retrieve(webhook_uuid:)
+      Webhooks::Subscription.new get_request("webhook_subscriptions/#{webhook_uuid}").dig("resource").merge(client: client)
+    end
+
+    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.6.0"
+  VERSION = "0.7.0"
 end

data/lib/calendlyr.rb

@@ -3,28 +3,80 @@ require "calendlyr/version"
 module Calendlyr
   autoload :Client, "calendlyr/client"
   autoload :Collection, "calendlyr/collection"
-  autoload :Error, "calendlyr/error"
-  autoload :Resource, "calendlyr/resource"
   autoload :Object, "calendlyr/object"
+  autoload :Resource, "calendlyr/resource"
+
+  # Errors
+  autoload :BadRequest, "calendlyr/error"
+  autoload :Error, "calendlyr/error"
+  autoload :ExternalCalendarEror, "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"
 
   # High-level categories of Calendly API calls
-  autoload :UserResource, "calendlyr/resources/users"
-  autoload :EventTypeResource, "calendlyr/resources/event_types"
-  autoload :OrganizationResource, "calendlyr/resources/organizations"
-  autoload :EventResource, "calendlyr/resources/events"
-  autoload :EventInviteeResource, "calendlyr/resources/event_invitees"
-  autoload :SchedulingLinkResource, "calendlyr/resources/scheduling_links"
-  autoload :WebhookResource, "calendlyr/resources/webhooks"
+  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"
 
   # Classes used to return a nicer object wrapping the response data
-  autoload :User, "calendlyr/objects/users"
-  autoload :EventType, "calendlyr/objects/event_types"
-  autoload :Event, "calendlyr/objects/events"
-  autoload :Organization, "calendlyr/objects/organizations"
-  autoload :Invitation, "calendlyr/objects/invitations"
-  autoload :EventInvitee, "calendlyr/objects/event_invitees"
-  autoload :SchedulingLink, "calendlyr/objects/scheduling_links"
-  autoload :Membership, "calendlyr/objects/memberships"
-  autoload :Webhook, "calendlyr/objects/webhooks"
+  autoload :ActivityLog, "calendlyr/objects/activity_log"
+  autoload :Event, "calendlyr/objects/event"
+  autoload :EventType, "calendlyr/objects/event_type"
+  autoload :Group, "calendlyr/objects/group"
+  autoload :Organization, "calendlyr/objects/organization"
+  autoload :RoutingForm, "calendlyr/objects/routing_form"
+  autoload :SchedulingLink, "calendlyr/objects/scheduling_link"
+  autoload :Share, "calendlyr/objects/share"
+  autoload :User, "calendlyr/objects/user"
+
+  module Availabilities
+    autoload :Rule, "calendlyr/objects/availabilities/rule"
+    autoload :UserSchedule, "calendlyr/objects/availabilities/user_schedule"
+    autoload :UserBusyTime, "calendlyr/objects/availabilities/user_busy_time"
+  end
+
+  module Events
+    autoload :Cancellation, "calendlyr/objects/events/cancellation"
+    autoload :Guest, "calendlyr/objects/events/guest"
+    autoload :Invitee, "calendlyr/objects/events/invitee"
+    autoload :InviteeNoShow, "calendlyr/objects/events/invitee_no_show"
+  end
+
+  module EventTypes
+    autoload :AvailableTime, "calendlyr/objects/event_types/available_time"
+    autoload :Membership, "calendlyr/objects/event_types/membership"
+    autoload :Profile, "calendlyr/objects/event_types/profile"
+  end
+
+  module Groups
+    autoload :Relationship, "calendlyr/objects/groups/relationship"
+  end
+
+  module Organizations
+    autoload :Invitation, "calendlyr/objects/organizations/invitation"
+    autoload :Membership, "calendlyr/objects/organizations/membership"
+  end
+
+  module RoutingForms
+    autoload :Submission, "calendlyr/objects/routing_forms/submission"
+  end
+
+  module Webhooks
+    autoload :Subscription, "calendlyr/objects/webhooks/subscription"
+    autoload :InviteePayload, "calendlyr/objects/webhooks/invitee_payload"
+    autoload :Payload, "calendlyr/objects/webhooks/payload"
+  end
 end

data/test/calendlyr/objects/activity_log_test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ActivityLogObjectTest < Minitest::Test
+  def setup
+    json = JSON.parse(fixture_file("objects/activity_log")).merge(client: client)
+    @activity_log = Calendlyr::ActivityLog.new(json)
+
+    user_uuid = "SDLKJENFJKD123"
+    response = {body: fixture_file("users/retrieve"), status: 200}
+    stub(path: "users/#{user_uuid}", response: response)
+  end
+
+  def test_associated_organization
+    organization = @activity_log.associated_organization
+
+    assert_equal Calendlyr::Organization, organization.class
+  end
+
+  def test_associated_actor
+    user = @activity_log.associated_actor
+
+    assert_equal "John Doe", user.name
+  end
+end

data/test/calendlyr/objects/availabilities/rule_test.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Availabilities
+  class RuleObjectTest < Minitest::Test
+    def setup
+      json = JSON.parse(fixture_file("objects/availabilities/rule")).merge(client: client)
+      @rule = Calendlyr::Availabilities::Rule.new(json)
+    end
+
+    def test_type
+      assert_equal "wday", @rule.type
+    end
+
+    def test_intervals
+      assert_equal 1, @rule.intervals.size
+    end
+
+    def test_wday
+      assert_equal "sunday", @rule.wday
+    end
+  end
+end

data/test/calendlyr/objects/availabilities/user_busy_time_test.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "test_helper"
+module Availabilities
+  class UserBusyTimeObjectTest < Minitest::Test
+    def setup
+      response = {body: fixture_file("events/retrieve"), status: 200}
+      stub(path: "scheduled_events/abc123", response: response)
+      json = JSON.parse(fixture_file("objects/availabilities/user_busy_time")).merge(client: client)
+      @user_busy_time = Calendlyr::Availabilities::UserBusyTime.new(json)
+    end
+
+    def test_associated_event
+      assert_equal Calendlyr::Event, @user_busy_time.associated_event.class
+    end
+
+    def test_type
+      assert_equal "calendly", @user_busy_time.type
+    end
+  end
+end

data/test/calendlyr/objects/availabilities/user_schedule_test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module Availabilities
+  class UserScheduleObjectTest < Minitest::Test
+    def setup
+      stub(path: "users/abc123", response: {body: fixture_file("users/retrieve"), status: 200})
+      json = JSON.parse(fixture_file("objects/availabilities/user_schedule")).merge(client: client)
+      @user_availability_schedule = Calendlyr::Availabilities::UserSchedule.new(json)
+    end
+
+    def test_associated_user
+      assert_equal Calendlyr::User, @user_availability_schedule.associated_user.class
+    end
+
+    def test_availability_schedule
+      assert_equal "America\\/New_York", @user_availability_schedule.timezone
+    end
+
+    def test_availability_rules
+      assert_equal 7, @user_availability_schedule.availability_rules.count
+      assert_equal Calendlyr::Availabilities::Rule, @user_availability_schedule.availability_rules.first.class
+    end
+  end
+end

data/test/calendlyr/objects/event_test.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class EventObjectTest < Minitest::Test
+  def setup
+    json = JSON.parse(fixture_file("objects/event")).merge(client: client)
+    @event = Calendlyr::Event.new(json)
+
+    user_uuid = "GBGBDCAADAEDCRZ2"
+    response = {body: fixture_file("users/retrieve"), status: 200}
+    stub(path: "users/#{user_uuid}", response: response)
+  end
+
+  def test_memberships
+    memberships = @event.memberships
+
+    assert_equal 1, memberships.count
+    assert_equal "John Doe", memberships.first.name
+    assert_instance_of Calendlyr::User, memberships.first
+  end
+
+  def test_cancel
+    response = {body: fixture_file("events/cancel_invitee"), status: 201}
+    stub(method: :post, path: "scheduled_events/#{@event.uuid}/cancellation", response: response)
+
+    cancellation = @event.cancel(reason: "I'm busy")
+
+    assert_instance_of Calendlyr::Events::Cancellation, cancellation
+    assert_equal "string", cancellation.reason
+  end
+end

data/test/calendlyr/objects/event_type_test.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class EventTypeObjectTest < Minitest::Test
+  def setup
+    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)
+  end
+
+  def test_associated_profile
+    profile = @event_type.associated_profile
+
+    assert_equal Calendlyr::EventTypes::Profile, profile.class
+    assert_equal "Tamara Jones", profile.name
+  end
+
+  def test_create_share
+    share = @event_type.create_share
+
+    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