calendlyr 0.6.0 → 0.7.0

data/docs/resources/user.md

@@ -0,0 +1,111 @@
+# User Calendlyr::User
+
+Information about the user.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs/647961f90c0dd-user)
+
+## Client requests
+
+### Retrieve
+
+Returns information about a specified User.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs/ff9832c5a6640-get-user)
+
+```ruby
+client.users.retrieve(uuid: user_uuid)
+#=> #<Calendlyr::User>
+```
+
+### Me
+
+Returns basic information about your user account.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs/005832c83aeae-get-current-user)
+
+```ruby
+client.users.me
+#=> #<Calendlyr::User>
+```
+
+#### Easy access
+
+Probably you need to make many calls through `client.me`, so we decided to not make calls for every `client.me` reference by memoizing it the first time.
+
+```ruby
+client.me # makes a call and memoize the response
+client.me # no call, value memoized
+```
+
+#### Force reload
+
+However, if you need to reload the content of `me` you can `force_relaod` to force a new call.
+
+```ruby
+client.me(force_reload: true) # makes a new call and update memoized value
+```
+
+## Object methods
+
+### Associated Organization
+
+```ruby
+user.associated_organization
+#=> #<Calendlyr::Organization>
+```
+
+### Availability Schedules
+
+For the example bellow we will use not parameters, but you can use the allowed parameters in Calendly docs.
+
+```ruby
+user.availability_schedules
+#=> #<Calendlyr::Collection @data=[#<Calendlyr::Availabilities::UserSchedule>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
+```
+
+### Memberships
+
+Based on your user organization
+
+For the example bellow we will use not parameters, but you can use the allowed parameters in Calendly docs.
+
+```ruby
+user.memberships
+#=> #<Calendlyr::Collection @data=[#<Calendlyr::Organizations::Membership>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
+```
+
+### Organization Membership
+
+Based on your user organization
+
+```ruby
+user.membership(uuid: membership_uuid)
+#=> #<Calendlyr::Organizations::Membership>
+```
+
+### Event Types
+
+For the example bellow we will use not parameters, but you can use the allowed parameters in Calendly docs.
+
+```ruby
+user.event_types
+#=> #<Calendlyr::Collection @data=[#<Calendlyr::EventType>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
+```
+
+### Events
+
+For the example bellow we will use not parameters, but you can use the allowed parameters in Calendly docs.
+
+```ruby
+user.events
+#=> #<Calendlyr::Collection @data=[#<Calendlyr::Event>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
+```
+
+### Busy Times
+
+For the example bellow we will use only required parameters, but you can use any other parameter as well.
+
+```ruby
+user.busy_times(start_time: start_time, end_time: end_time)
+#=> #<Calendlyr::Collection @data=[#<Calendlyr::Availabilities::UserBusyTime>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
+```

data/docs/resources/webhooks/invitee_payload.md

@@ -0,0 +1,42 @@
+# Webhook Invitee Payload Calendlyr::Wehooks::InviteePayload
+
+The payload that is sent via Webhook when an invitee creates or schedules a meeting, and when an invitee cancels.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs/b92768854bc06-invitee-payload)
+
+## Object methods
+
+### Associated Event
+
+```ruby
+webhook_invitee_payload.associated_organization
+#=> #<Calendlyr::Event>
+```
+
+### Associated Routing Form Submission
+
+```ruby
+webhook_invitee_payload.associated_routing_form_submission
+#=> #<Calendlyr::RoutingForms::Submission>
+```
+
+### Associated Invitee No Show
+
+```ruby
+webhook_invitee_payload.associated_invitee_no_show
+#=> #<Calendlyr::Events::InviteeNoShow>
+```
+
+### active?
+
+```ruby
+webhook_subscription.active?
+#=> true
+```
+
+### disabled?
+
+```ruby
+webhook_subscription.disabled?
+#=> false
+```

data/docs/resources/webhooks/payload.md

@@ -0,0 +1,5 @@
+# Webhook Payload Calendlyr::Wehooks::Payload
+
+Webhook Payload Object
+
+Visit official [API Doc](https://developer.calendly.com/api-docs/69c58da556b61-webhook-payload)

data/docs/resources/webhooks/subscription.md

@@ -0,0 +1,96 @@
+# Webhook Subscription Calendlyr::Wehooks::Subscription
+
+Webhook Subscription Object.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs/9950e4dff7351-webhook-subscription)
+
+## Client requests
+
+### Create
+
+Create a Webhook Subscription for an Organization or User.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs/c1ddc06ce1f1b-create-webhook-subscription)
+
+```ruby
+client.webhooks.create(url: 'https://example.com/webhook', events: ['invitee.created'], organization: organization_uri, scope: 'organization')
+#=> #<Calendlyr::Webhooks::Subscription>
+
+client.webhooks.create(url: 'https://example.com/webhook', events: ['invitee.created'], organization: organization_uri, user: user_uri, scope: 'user')
+#=> #<Calendlyr::Webhooks::Subscription>
+
+client.webhooks.create(url: 'https://example.com/webhook', events: ['invitee.created'], organization: organization_uri, group: group_uri, scope: 'group')
+#=> #<Calendlyr::Webhooks::Subscription>
+```
+
+### Retrieve
+
+Get a specified Webhook Subscription.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs/4d800dc2cb119-get-webhook-subscription)
+
+```ruby
+client.webhooks.retrieve(webhook_uuid: webhook_uuid)
+#=> #<Calendlyr::Webhooks::Subscription>
+```
+
+### List
+
+Get a list of Webhook Subscriptions for a specified Organization or User.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs/faac832d7c57d-list-webhook-subscriptions)
+
+For the example bellow we will use only required parameters, but you can use any other parameter as well.
+
+```ruby
+client.webhooks.list(organization: organization_uri, scope: 'organization')
+#=> #<Calendlyr::Collection @data=[#<Calendlyr::Webhooks::Subscription>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
+```
+
+### Delete
+
+Delete a Webhook Subscription.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs/565b97f62dafe-delete-webhook-subscription)
+
+```ruby
+client.webhooks.delete(webhook_uuid: webhook_uuid)
+#=>
+```
+
+## Object methods
+
+### Associated Organization
+
+```ruby
+webhook_subscription.associated_organization
+#=> #<Calendlyr::Organization>
+```
+
+### Associated User
+
+```ruby
+webhook_subscription.associated_user
+#=> #<Calendlyr::User>
+```
+
+### Associated Creator
+
+```ruby
+webhook_subscription.associated_creator
+#=> #<Calendlyr::User>
+```
+
+### active?
+
+```ruby
+webhook_subscription.active?
+#=> true
+```
+
+### disabled?
+
+```ruby
+webhook_subscription.disabled?
+#=> false
+```

data/lib/calendlyr/client.rb

@@ -8,6 +8,10 @@ module Calendlyr
       @token = token
     end
 
+    def availability
+      AvailabilityResource.new(self)
+    end
+
     def me(force_reload: false)
       @me = nil if force_reload
       @me ||= users.me
@@ -33,14 +37,26 @@ module Calendlyr
       EventResource.new(self)
     end
 
-    def event_invitees
-      EventInviteeResource.new(self)
+    def groups
+      GroupResource.new(self)
+    end
+
+    def outgoing_communications
+      OutgoingCommunicationResource.new(self)
+    end
+
+    def routing_forms
+      RoutingFormResource.new(self)
     end
 
     def scheduling_links
       SchedulingLinkResource.new(self)
     end
 
+    def shares
+      ShareResource.new(self)
+    end
+
     def webhooks
       WebhookResource.new(self)
     end

data/lib/calendlyr/collection.rb

@@ -5,9 +5,9 @@ module Calendlyr
   class Collection
     attr_reader :data, :count, :next_page, :next_page_token, :client
 
-    def self.from_response(response, key:, type:, client:)
+    def self.from_response(response, type:, client:)
       new(
-        data: response[key].map { |attrs| type.new(attrs.merge(client: client)) },
+        data: response["collection"].map { |attrs| type.new(attrs.merge(client: client)) },
         count: response.dig("pagination", "count"),
         next_page: response.dig("pagination", "next_page"),
         client: client

data/lib/calendlyr/error.rb

@@ -1,4 +1,45 @@
 module Calendlyr
-  class Error < StandardError
+  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 ExternalCalendarEror < StandardError; end
+
+  class InternalServerError < StandardError; end
+
+  class ResponseErrorHandler
+    ERROR_TYPES = {
+      "400" => BadRequest,
+      "401" => Unauthenticated,
+      "403" => PermissionDenied,
+      "404" => NotFound,
+      "424" => ExternalCalendarEror,
+      "500" => InternalServerError
+    }
+
+    def initialize(code, body)
+      @code = code
+      @body = body
+    end
+
+    def error
+      error_type.new("[Error #{@code}] #{@body["title"]}. #{@body["message"]}")
+    end
+
+    private
+
+    def error_type
+      return PaymentRequired if @code == "403" && @body["message"].include?("upgrade")
+
+      ERROR_TYPES[@code]
+    end
   end
 end

data/lib/calendlyr/object.rb

@@ -2,8 +2,12 @@ require "ostruct"
 
 module Calendlyr
   class Object < OpenStruct
+    def self.get_slug(path)
+      path.split("/").last
+    end
+
     def initialize(attributes)
-      super to_ostruct(attributes.merge(uuid: extract_uuid(attributes)))
+      super(to_ostruct(attributes.merge(uuid: extract_uuid(attributes))))
     end
 
     def to_ostruct(obj)
@@ -21,7 +25,7 @@ module Calendlyr
     end
 
     def get_slug(path)
-      path.split("/").last
+      Calendlyr::Object.get_slug(path)
     end
   end
 end

data/lib/calendlyr/objects/activity_log.rb

@@ -0,0 +1,11 @@
+module Calendlyr
+  class ActivityLog < Object
+    def associated_organization
+      Organization.new({"uri" => organization}.merge(client: client))
+    end
+
+    def associated_actor
+      client.users.retrieve(uuid: get_slug(actor.uri))
+    end
+  end
+end

data/lib/calendlyr/objects/availabilities/rule.rb

@@ -0,0 +1,4 @@
+module Calendlyr
+  class Availabilities::Rule < Object
+  end
+end

data/lib/calendlyr/objects/availabilities/user_busy_time.rb

@@ -0,0 +1,7 @@
+module Calendlyr
+  class Availabilities::UserBusyTime < Object
+    def associated_event
+      client.events.retrieve(uuid: get_slug(event.uri))
+    end
+  end
+end

data/lib/calendlyr/objects/availabilities/user_schedule.rb

@@ -0,0 +1,13 @@
+module Calendlyr
+  class Availabilities::UserSchedule < Object
+    def associated_user
+      client.users.retrieve(uuid: get_slug(user))
+    end
+
+    def availability_rules
+      rules.map do |rule|
+        Availabilities::Rule.new(rule.to_h.merge(client: client))
+      end
+    end
+  end
+end

data/lib/calendlyr/objects/event.rb

@@ -0,0 +1,11 @@
+module Calendlyr
+  class Event < Object
+    def memberships
+      event_memberships.map { |membership| client.users.retrieve(uuid: get_slug(membership.user)) }
+    end
+
+    def cancel(reason: nil)
+      client.events.cancel(uuid: uuid, reason: reason)
+    end
+  end
+end

data/lib/calendlyr/objects/event_type.rb

@@ -0,0 +1,15 @@
+module Calendlyr
+  class EventType < Object
+    def associated_profile
+      EventTypes::Profile.new(profile.to_h.merge(client: client))
+    end
+
+    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/available_time.rb

@@ -0,0 +1,4 @@
+module Calendlyr
+  class EventTypes::AvailableTime < Object
+  end
+end

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

@@ -0,0 +1,11 @@
+module Calendlyr
+  class EventTypes::Membership < Object
+    def associated_event_type
+      client.event_types.retrieve(uuid: get_slug(event_type.uri))
+    end
+
+    def associated_member
+      client.users.retrieve(uuid: get_slug(member.uri))
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Calendlyr
+  class EventTypes::Profile < Object
+    def associated_owner
+      client.users.retrieve(uuid: get_slug(owner))
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+module Calendlyr
+  class Events::Cancellation < Object
+  end
+end

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

@@ -0,0 +1,4 @@
+module Calendlyr
+  class Events::Guest < Object
+  end
+end

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

@@ -0,0 +1,11 @@
+module Calendlyr
+  class Events::Invitee < Object
+    def cancel(reason: nil)
+      client.events.cancel(uuid: uuid, reason: reason)
+    end
+
+    def create_no_shows
+      client.events.create_invitee_no_show(invitee: uri)
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Calendlyr
+  class Events::InviteeNoShow < Object
+    def delete
+      client.events.delete_invitee_no_show(uuid: uuid)
+    end
+  end
+end

data/lib/calendlyr/objects/group.rb

@@ -0,0 +1,15 @@
+module Calendlyr
+  class Group < Object
+    def associated_organization
+      Organization.new({"uri" => organization}.merge(client: client))
+    end
+
+    def events(**params)
+      client.events.list(**params.merge(group: uri))
+    end
+
+    def group_relationships(**params)
+      client.groups.list_relationships(**params.merge(group: uri))
+    end
+  end
+end

data/lib/calendlyr/objects/groups/relationship.rb

@@ -0,0 +1,15 @@
+module Calendlyr
+  class Groups::Relationship < Object
+    def associated_organization
+      Organization.new({"uri" => organization}.merge(client: client))
+    end
+
+    def associated_group
+      client.groups.retrieve(uuid: get_slug(group))
+    end
+
+    def associated_owner
+      client.organizations.retrieve_membership(uuid: get_slug(owner.uri))
+    end
+  end
+end

data/lib/calendlyr/objects/organization.rb

@@ -0,0 +1,67 @@
+module Calendlyr
+  class Organization < Object
+    def activity_logs(**params)
+      client.organizations.activity_log(**params.merge(organization: uri))
+    end
+
+    def events(**params)
+      client.events.list(**params.merge(organization: uri))
+    end
+
+    def event_types(**params)
+      client.event_types.list(**params.merge(organization: uri))
+    end
+
+    def routing_forms(**params)
+      client.routing_forms.list(**params.merge(organization: uri))
+    end
+
+    # Groups
+    def groups(**params)
+      client.groups.list(**params.merge(organization: uri))
+    end
+
+    def group_relationships(**params)
+      client.groups.list_relationships(**params.merge(organization: uri))
+    end
+
+    # Memberships
+    def memberships(**params)
+      client.organizations.list_memberships(**params.merge(organization: uri))
+    end
+
+    def membership(uuid:)
+      client.organizations.retrieve_membership(uuid: uuid)
+    end
+
+    # Webhooks
+    def webhooks(scope:, **params)
+      client.webhooks.list(**params.merge(organization: uri, scope: scope))
+    end
+
+    def create_webhook(url:, events:, scope:, **params)
+      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))
+    end
+
+    def invitations(**params)
+      client.organizations.list_invitations(**params.merge(uuid: uuid))
+    end
+
+    def invitation(invitation_uuid:)
+      client.organizations.retrieve_invitation(org_uuid: uuid, uuid: invitation_uuid)
+    end
+
+    def revoke_invitation(invitation_uuid:)
+      client.organizations.revoke_invitation(org_uuid: uuid, uuid: invitation_uuid)
+    end
+  end
+end

data/lib/calendlyr/objects/organizations/invitation.rb

@@ -0,0 +1,15 @@
+module Calendlyr
+  class Organizations::Invitation < Object
+    def associated_organization
+      Organization.new({"uri" => organization}.merge(client: client))
+    end
+
+    def associated_user
+      client.users.retrieve(uuid: get_slug(user))
+    end
+
+    def revoke
+      associated_organization.revoke_invitation(invitation_uuid: uuid)
+    end
+  end
+end

data/lib/calendlyr/objects/organizations/membership.rb

@@ -0,0 +1,15 @@
+module Calendlyr
+  class Organizations::Membership < Object
+    def associated_organization
+      Organization.new({"uri" => organization}.merge(client: client))
+    end
+
+    def associated_user
+      client.users.retrieve(uuid: get_slug(user.uri))
+    end
+
+    def group_relationships(**params)
+      client.groups.list_relationships(**params.merge(owner: uri))
+    end
+  end
+end

data/lib/calendlyr/objects/routing_form.rb

@@ -0,0 +1,11 @@
+module Calendlyr
+  class RoutingForm < Object
+    def associated_organization
+      Organization.new({"uri" => organization}.merge(client: client))
+    end
+
+    def submissions(**params)
+      client.routing_forms.list_submissions(**params.merge(form: uri))
+    end
+  end
+end

data/lib/calendlyr/objects/routing_forms/submission.rb

@@ -0,0 +1,7 @@
+module Calendlyr
+  class RoutingForms::Submission < Object
+    def associated_routing_form
+      client.routing_forms.retrieve(uuid: get_slug(routing_form))
+    end
+  end
+end

data/lib/calendlyr/objects/scheduling_link.rb

@@ -0,0 +1,9 @@
+module Calendlyr
+  class SchedulingLink < Object
+    def event_type
+      return unless owner_type == "EventType"
+
+      client.event_types.retrieve(uuid: get_slug(owner))
+    end
+  end
+end