nylas 5.4.1 → 5.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29f07de83f9f9129d2604b28ad5efd02d21cdc81075e92b16129d6ebfb3509fc
-  data.tar.gz: f1259c4907de58f04082c6c2e0a80a7d2d50b99a13efc70714f7370ead25d420
+  metadata.gz: 4d8d9639941076724b3e9ae95b85a2e4a48c8f663a35b03f5f26473c5c87b208
+  data.tar.gz: 4b2733e86538a6dd7ac3069dc5738997ea8db1b7be13b1a8de9bef5c868ec1d5
 SHA512:
-  metadata.gz: 9117a61ff796ee58ee596d2ce7f1d41874a0f79f452d678f66dc768e8cf7db59580085f069946e4d4a634b47a85ebd4696f59b59960ecdec805c0244575bbc7a
-  data.tar.gz: b53cedb0c8c2334da1f6e092819eea787ec4c856eafdb606ce29713605eed834044e780dfd6ed6fafc0ee47c6c1bfd48d947237dc4dd9a6d84d531c4c5cc1daf
+  metadata.gz: 56b9216d9e5f37a0c449d999891a76a06e1ed8dd8925efe5186d8d59d16105da76ea3b8a5599d88a9e8e83bd2862bc71cc7491957ac8c8da8718a825af2a2a2a
+  data.tar.gz: 5fa04ae09e9692f0c954926ae8e7d541388597a12a154dd8bf82b78c40e91b7b9b73508c5d39b6a2c604ed5d53f5eec86379687dc9b79da81b4a8571d0500460

data/lib/nylas/account.rb

@@ -7,15 +7,18 @@ module Nylas
     include Model
     self.listable = true
     self.showable = true
+    self.updatable = true
+    self.destroyable = true
 
-    attribute :id, :string
-    attribute :account_id, :string
-    attribute :billing_state, :string
-    attribute :sync_state, :string
-    attribute :provider, :string
+    attribute :id, :string, read_only: true
+    attribute :account_id, :string, read_only: true
+    attribute :billing_state, :string, read_only: true
+    attribute :sync_state, :string, read_only: true
+    attribute :provider, :string, read_only: true
 
-    attribute :email, :string
-    attribute :trial, :boolean
+    attribute :email, :string, read_only: true
+    attribute :trial, :boolean, read_only: true
+    attribute :metadata, :hash
 
     def upgrade
       response = execute(method: :post, path: "#{resource_path}/upgrade")
@@ -34,6 +37,15 @@ module Nylas
       response[:success]
     end
 
+    # Return information about an account's access token
+    # @param access_token [String] The access token to inquire about
+    # @return [TokenInfo] The access token information
+    def token_info(access_token)
+      payload = JSON.dump(access_token: access_token)
+      response = execute(method: :post, path: "#{resource_path}/token-info", payload: payload)
+      TokenInfo.new(**response)
+    end
+
     def self.resources_path(api:)
       "/a/#{api.app_id}/accounts"
     end

data/lib/nylas/api.rb

@@ -48,7 +48,11 @@ module Nylas
       "#{api_server}/oauth/authorize?#{URI.encode_www_form(params)}"
     end
 
-    def exchange_code_for_token(code)
+    # Exchanges an authorization code for an access token
+    # @param code [String] The authorization code to exchange
+    # @param return_full_response [Boolean] If true, returns the full response body instead of just the token
+    # @return [String | Hash] Returns just the access token as a string, or the full response as a hash
+    def exchange_code_for_token(code, return_full_response: false)
       data = {
         "client_id" => app_id,
         "client_secret" => client.app_secret,
@@ -56,8 +60,8 @@ module Nylas
         "code" => code
       }
 
-      response_json = execute(method: :post, path: "/oauth/token", payload: data)
-      response_json[:access_token]
+      response = execute(method: :post, path: "/oauth/token", payload: data)
+      return_full_response ? response : response[:access_token]
     end
 
     # @return [Collection<Contact>] A queryable collection of Contacts
@@ -81,9 +85,9 @@ module Nylas
       @accounts ||= Collection.new(model: Account, api: as(client.app_secret))
     end
 
-    # @return [Collection<Calendar>] A queryable collection of {Calendar}s
+    # @return [CalendarCollection<Calendar>] A queryable collection of {Calendar}s
     def calendars
-      @calendars ||= Collection.new(model: Calendar, api: self)
+      @calendars ||= CalendarCollection.new(model: Calendar, api: self)
     end
 
     # @return [DeltasCollection<Delta>] A queryable collection of Deltas, which are themselves a collection.
@@ -96,7 +100,7 @@ module Nylas
       @drafts ||= Collection.new(model: Draft, api: self)
     end
 
-    # @return [Collection<Event>] A queryable collection of {Event}s
+    # @return [EventCollection<Event>] A queryable collection of {Event}s
     def events
       @events ||= EventCollection.new(model: Event, api: self)
     end
@@ -126,11 +130,29 @@ module Nylas
       @room_resources ||= Collection.new(model: RoomResource, api: self)
     end
 
+    # @return[Collection<JobStatus>] A queryable collection of {JobStatus} objects
+    def job_statuses
+      @job_statuses ||= Collection.new(model: JobStatus, api: self)
+    end
+
+    # @return[SchedulerCollection<Scheduler>] A queryable collection of {Scheduler} objects
+    def scheduler
+      # Make a deep copy of the API as the scheduler API uses a different base URL
+      scheduler_api = Marshal.load(Marshal.dump(self))
+      scheduler_api.client.api_server = "https://api.schedule.nylas.com"
+      @scheduler ||= SchedulerCollection.new(model: Scheduler, api: scheduler_api)
+    end
+
     # @return[Neural] A {Neural} object that provides
     def neural
       @neural ||= Neural.new(api: self)
     end
 
+    # @return [Collection<Component>] A queryable collection of {Component}s
+    def components
+      @components ||= ComponentCollection.new(model: Component, api: as(client.app_secret))
+    end
+
     # Revokes access to the Nylas API for the given access token
     # @return [Boolean]
     def revoke(access_token)
@@ -138,6 +160,25 @@ module Nylas
       response.code == 200 && response.empty?
     end
 
+    # Returns the application details
+    # @return [ApplicationDetail] The application details
+    def application_details
+      response = client.as(client.app_secret).execute(method: :get, path: "/a/#{app_id}")
+      ApplicationDetail.new(**response)
+    end
+
+    # Updates the application details
+    # @param application_details [ApplicationDetail] The updated application details
+    # @return [ApplicationDetails] The updated application details, returned from the server
+    def update_application_details(application_details)
+      response = client.as(client.app_secret).execute(
+        method: :put,
+        path: "/a/#{app_id}",
+        payload: JSON.dump(application_details.to_h)
+      )
+      ApplicationDetail.new(**response)
+    end
+
     # Returns list of IP addresses
     # @return [Hash]
     # hash has keys of :updated_at (unix timestamp) and :ip_addresses (array of strings)
@@ -155,7 +196,7 @@ module Nylas
     end
 
     # Allows you to get an API that acts as a different user but otherwise has the same settings
-    # @param [String] Oauth Access token or app secret used to authenticate with the API
+    # @param access_token [String] Oauth Access token or app secret used to authenticate with the API
     # @return [API]
     def as(access_token)
       API.new(client: client.as(access_token))
@@ -171,6 +212,7 @@ module Nylas
       @webhooks ||= Collection.new(model: Webhook, api: as(client.app_secret))
     end
 
+    # TODO: Move this into calendar collection
     def free_busy(emails:, start_time:, end_time:)
       FreeBusyCollection.new(
         api: self,

data/lib/nylas/application_details.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent a Nylas Application Detail object.
+  # @see https://developer.nylas.com/docs/api/#get/a/client_id
+  class ApplicationDetail
+    include Model::Attributable
+
+    attribute :application_name, :string
+    attribute :icon_url, :string
+    has_n_of_attribute :redirect_uris, :string
+  end
+end

data/lib/nylas/calendar.rb

@@ -6,7 +6,8 @@ module Nylas
   class Calendar
     include Model
     self.resources_path = "/calendars"
-    allows_operations(listable: true, filterable: true, showable: true)
+    allows_operations(creatable: true, listable: true, filterable: true, showable: true, updatable: true,
+                      destroyable: true)
 
     attribute :id, :string
     attribute :account_id, :string
@@ -20,6 +21,8 @@ module Nylas
     attribute :timezone, :string
 
     attribute :read_only, :boolean
+    attribute :metadata, :hash
+    attribute :job_status_id, :string, read_only: true
 
     def read_only?
       read_only == true

data/lib/nylas/calendar_collection.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Additional methods for some of Calendar's other functionality
+  # @see https://developer.nylas.com/docs/connectivity/calendar
+  class CalendarCollection < Collection
+    def availability(duration_minutes:,
+                     interval:,
+                     start_time:,
+                     end_time:,
+                     emails:,
+                     buffer: nil,
+                     round_robin: nil,
+                     free_busy: [],
+                     open_hours: [])
+      validate_open_hours(emails, free_busy, open_hours) unless open_hours.empty?
+
+      execute_availability("/calendars/availability",
+                           duration_minutes: duration_minutes,
+                           interval: interval,
+                           start_time: start_time,
+                           end_time: end_time,
+                           emails: emails,
+                           buffer: buffer,
+                           round_robin: round_robin,
+                           free_busy: free_busy,
+                           open_hours: open_hours)
+    end
+
+    def consecutive_availability(duration_minutes:,
+                                 interval:,
+                                 start_time:,
+                                 end_time:,
+                                 emails:,
+                                 buffer: nil,
+                                 free_busy: [],
+                                 open_hours: [])
+      validate_open_hours(emails, free_busy, open_hours) unless open_hours.empty?
+
+      execute_availability("/calendars/availability/consecutive",
+                           duration_minutes: duration_minutes,
+                           interval: interval,
+                           start_time: start_time,
+                           end_time: end_time,
+                           emails: emails,
+                           buffer: buffer,
+                           free_busy: free_busy,
+                           open_hours: open_hours)
+    end
+
+    private
+
+    def execute_availability(path, **payload)
+      api.execute(
+        method: :post,
+        path: path,
+        payload: JSON.dump(payload)
+      )
+    end
+
+    def validate_open_hours(emails, free_busy, open_hours)
+      raise TypeError, "open_hours' must be an array." unless open_hours.is_a?(Array)
+
+      open_hours_emails = map_open_hours_emails(open_hours)
+      free_busy_emails = map_free_busy_emails(free_busy)
+      emails = merge_arrays(emails) if emails[0].is_a?(Array)
+
+      open_hours_emails.each do |email|
+        next if emails.include?(email) || free_busy_emails.include?(email)
+
+        raise ArgumentError, "Open Hours cannot contain an email not present in the main email list or
+the free busy email list."
+      end
+    end
+
+    def map_open_hours_emails(open_hours)
+      open_hours_emails = []
+      open_hours.map do |oh|
+        open_hours_emails += oh.emails
+      end
+      open_hours_emails
+    end
+
+    def map_free_busy_emails(free_busy)
+      free_busy_emails = []
+      free_busy.map do |fb|
+        free_busy_emails.append(fb.email)
+      end
+      free_busy_emails
+    end
+
+    def merge_arrays(array)
+      list = []
+      array.each do |x|
+        list += x
+      end
+      list
+    end
+  end
+end

data/lib/nylas/component.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent a the Component Schema.
+  class Component
+    include Model
+    allows_operations(creatable: true, listable: true, filterable: true, showable: true, updatable: true,
+                      destroyable: true)
+
+    attribute :id, :string, read_only: true
+    attribute :account_id, :string
+    attribute :name, :string
+    attribute :type, :string
+    attribute :action, :integer
+    attribute :active, :boolean
+    attribute :settings, :hash
+    attribute :public_account_id, :string
+    attribute :public_token_id, :string
+    attribute :public_application_id, :string, read_only: true
+    attribute :access_token, :string
+    attribute :created_at, :date, read_only: true
+    attribute :updated_at, :date, read_only: true
+
+    has_n_of_attribute :allowed_domains, :string
+
+    def resources_path(*)
+      "/component/#{api.client.app_id}"
+    end
+  end
+end

data/lib/nylas/component_collection.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Additional configuration for the Component CRUD API
+  class ComponentCollection < Collection
+    def resources_path
+      "/component/#{api.client.app_id}"
+    end
+  end
+end

data/lib/nylas/contact.rb

@@ -30,6 +30,7 @@ module Nylas
     attribute :office_location, :string
     attribute :notes, :string
     attribute :source, :string
+    attribute :job_status_id, :string, read_only: true
 
     has_n_of_attribute :groups, :contact_group
     has_n_of_attribute :emails, :email_address

data/lib/nylas/draft.rb

@@ -27,6 +27,7 @@ module Nylas
     attribute :body, :string
     attribute :starred, :boolean
     attribute :unread, :boolean
+    attribute :metadata, :hash
 
     has_n_of_attribute :events, :event
     has_n_of_attribute :files, :file, read_only: true
@@ -35,6 +36,7 @@ module Nylas
     has_n_of_attribute :labels, :label
 
     attribute :tracking, :message_tracking
+    attribute :job_status_id, :string, read_only: true
 
     transfer :api, to: %i[events files folder labels]
 
@@ -75,18 +77,18 @@ module Nylas
       execute(method: :delete, path: resource_path, payload: attributes.serialize_for_api(keys: [:version]))
     end
 
-    private
-
-    def save_call
+    def save
       extract_file_ids!
 
       super
     end
 
+    private
+
     def extract_file_ids!
       files = self.files || []
 
-      self.file_ids = files.map(&:id)
+      self.file_ids ||= files.map(&:id)
     end
   end
 end

data/lib/nylas/event.rb

@@ -29,7 +29,9 @@ module Nylas
     attribute :when, :when
     attribute :metadata, :hash
     attribute :conferencing, :event_conferencing
+    has_n_of_attribute :notifications, :event_notification
     attribute :original_start_time, :unix_timestamp
+    attribute :job_status_id, :string, read_only: true
 
     attr_accessor :notify_participants
 
@@ -58,8 +60,47 @@ module Nylas
       rsvp.save
     end
 
+    # Generate an ICS file server-side, from an Event
+    # @param ical_uid [String] Unique identifier used events across calendaring systems
+    # @param method [String] Description of invitation and response methods for attendees
+    # @param prodid [String] Company-specific unique product identifier
+    # @return [String] String for writing directly into an ICS file
+    def generate_ics(ical_uid: nil, method: nil, prodid: nil)
+      raise ArgumentError, "Cannot generate an ICS file for an event without a Calendar ID or when set" unless
+        calendar_id && self.when
+
+      payload = build_ics_event_payload(ical_uid, method, prodid)
+      response = api.execute(
+        method: :post,
+        path: "#{resources_path}/to-ics",
+        payload: JSON.dump(payload)
+      )
+
+      response[:ics]
+    end
+
     private
 
+    def build_ics_event_payload(ical_uid, method, prodid)
+      payload = {}
+      if id
+        payload[:event_id] = id
+      else
+        payload = to_h(enforce_read_only: true)
+      end
+      ics_options = build_ics_options_payload(ical_uid, method, prodid)
+      payload["ics_options"] = ics_options unless ics_options.empty?
+      payload
+    end
+
+    def build_ics_options_payload(ical_uid, method, prodid)
+      payload = {}
+      payload["ical_uid"] = ical_uid if ical_uid
+      payload["method"] = method if method
+      payload["prodid"] = prodid if prodid
+      payload
+    end
+
     def query_params
       if notify_participants.nil?
         {}

data/lib/nylas/event_notification.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent the Event Notification object
+  # @see https://developer.nylas.com/docs/connectivity/calendar/event-notifications
+  class EventNotification
+    include Model::Attributable
+
+    attribute :type, :string
+    attribute :minutes_before_event, :integer
+    attribute :url, :string
+    attribute :payload, :string
+    attribute :subject, :string
+    attribute :body, :string
+    attribute :message, :string
+  end
+end

data/lib/nylas/file.rb

@@ -6,7 +6,7 @@ module Nylas
   class File
     include Model
     self.resources_path = "/files"
-    allows_operations(listable: true, showable: true, filterable: true, creatable: true)
+    allows_operations(listable: true, showable: true, filterable: true, creatable: true, destroyable: true)
 
     attribute :id, :string
     attribute :account_id, :string

data/lib/nylas/folder.rb

@@ -13,12 +13,12 @@ module Nylas
     self.updatable = true
     self.destroyable = true
 
-    attribute :id, :string
-    attribute :account_id, :string
-
-    attribute :object, :string
+    attribute :id, :string, read_only: true
+    attribute :account_id, :string, read_only: true
+    attribute :object, :string, read_only: true
 
     attribute :name, :string
     attribute :display_name, :string
+    attribute :job_status_id, :string, read_only: true
   end
 end

data/lib/nylas/job_status.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Ruby representation of a Nylas Job Status object
+  # @see https://developer.nylas.com/docs/api/#tag--Job-Status
+  class JobStatus
+    include Model
+    self.resources_path = "/job-statuses"
+    allows_operations(listable: true)
+
+    attribute :id, :string, read_only: true
+    attribute :account_id, :string, read_only: true
+    attribute :job_status_id, :string, read_only: true
+    attribute :action, :string, read_only: true
+    attribute :object, :string, read_only: true
+    attribute :status, :string, read_only: true
+    attribute :created_at, :unix_timestamp, read_only: true
+    attribute :original_data, :message, read_only: true
+
+    # Returns the status of a job as a boolean
+    # @return [Boolean] If the job was successful
+    def successful?
+      status == "successful"
+    end
+  end
+end

data/lib/nylas/label.rb

@@ -20,5 +20,6 @@ module Nylas
 
     attribute :name, :string
     attribute :display_name, :string
+    attribute :job_status_id, :string, read_only: true
   end
 end

data/lib/nylas/message.rb

@@ -8,7 +8,7 @@ module Nylas
     self.raw_mime_type = "message/rfc822"
     self.resources_path = "/messages"
     allows_operations(showable: true, listable: true, filterable: true, searchable: true, updatable: true)
-    UPDATABLE_ATTRIBUTES = %i[label_ids folder_id starred unread].freeze
+    UPDATABLE_ATTRIBUTES = %i[label_ids folder_id starred unread metadata].freeze
 
     attribute :id, :string
     attribute :object, :string
@@ -36,6 +36,8 @@ module Nylas
     has_n_of_attribute :files, :file
     attribute :folder, :folder
     attribute :folder_id, :string
+    attribute :metadata, :hash
+    attribute :job_status_id, :string, read_only: true
 
     has_n_of_attribute :labels, :label, read_only: true
     has_n_of_attribute :label_ids, :string
@@ -72,14 +74,10 @@ module Nylas
       self
     end
 
-    def save_call
+    def save
       handle_folder
 
-      execute(
-        method: :put,
-        payload: attributes.serialize_for_api,
-        path: resource_path
-      )
+      super
     end
 
     def handle_folder

data/lib/nylas/model/attributable.rb

@@ -17,8 +17,8 @@ module Nylas
       end
 
       # @return [Hash] Representation of the model with values serialized into primitives based on their Type
-      def to_h
-        attributes.to_h
+      def to_h(enforce_read_only: false)
+        attributes.to_h(enforce_read_only: enforce_read_only)
       end
 
       protected

data/lib/nylas/model/attribute_definition.rb

@@ -5,7 +5,7 @@ module Nylas
     # Define a particular attribute for a given model
     class AttributeDefinition
       extend Forwardable
-      def_delegators :type, :cast, :serialize
+      def_delegators :type, :cast, :serialize, :serialize_for_api
       attr_accessor :type_name, :read_only, :default
 
       def initialize(type_name:, read_only:, default:)

data/lib/nylas/model/attributes.rb

@@ -28,23 +28,34 @@ module Nylas
         end
       end
 
-      def to_h(keys: attribute_definitions.keys)
-        keys.each_with_object({}) do |key, casted_data|
-          value = attribute_definitions[key].serialize(self[key])
+      # Convert the object to hash
+      # @param keys [Array<String>] The keys included
+      # @param enforce_read_only [Boolean] Whether to enforce read_only property (serializing for API)
+      # @return [Hash] The hash representation of the object
+      def to_h(keys: attribute_definitions.keys, enforce_read_only: false)
+        casted_data = {}
+        keys.each do |key|
+          value = attribute_to_hash(key, enforce_read_only)
           # If the value is an empty hash but we specify that it is valid (via default value), serialize it
           casted_data[key] = value unless value.nil? || (value.respond_to?(:empty?) && value.empty? &&
             !(attribute_definitions[key].default == value && value.is_a?(Hash)))
         end
+        casted_data
       end
 
-      def serialize(keys: attribute_definitions.keys)
-        JSON.dump(to_h(keys: keys))
+      # Serialize the object
+      # @param keys [Array<String>] The keys included
+      # @param enforce_read_only [Boolean] Whether to enforce read_only property (serializing for API)
+      # @return [String] The serialized object as a JSON string
+      def serialize(keys: attribute_definitions.keys, enforce_read_only: false)
+        JSON.dump(to_h(keys: keys, enforce_read_only: enforce_read_only))
       end
 
+      # Serialize the object to an API-compatible JSON string
+      # @param keys [Array<String>] The keys included
+      # @return [String] The serialized object as a JSON string
       def serialize_for_api(keys: attribute_definitions.keys)
-        api_keys = keys.delete_if { |key| attribute_definitions[key].read_only == true }
-
-        serialize(keys: api_keys)
+        serialize(keys: keys, enforce_read_only: true)
       end
 
       def serialize_all_for_api(keys: attribute_definitions.keys)
@@ -68,6 +79,19 @@ module Nylas
       def default_attributes
         attribute_definitions.keys.zip([]).to_h
       end
+
+      # Convert the attribute value as a hash
+      # @param key [String] The attribute's key
+      # @param enforce_read_only [Boolean] Whether to enforce read_only property (serializing for API)
+      # @return [nil | Hash] The appropriately serialized value
+      def attribute_to_hash(key, enforce_read_only)
+        attribute_definition = attribute_definitions[key]
+        if enforce_read_only
+          attribute_definition.read_only == true ? nil : attribute_definition.serialize_for_api(self[key])
+        else
+          attribute_definition.serialize(self[key])
+        end
+      end
     end
   end
 end

data/lib/nylas/model/list_attribute_definition.rb

@@ -18,9 +18,17 @@ module Nylas
         list.map { |item| type.cast(item) }
       end
 
-      def serialize(list)
+      def serialize(list, enforce_read_only: false)
         list = default if list.nil? || list.empty?
-        list.map { |item| type.serialize(item) }
+        if enforce_read_only
+          list.map { |item| type.serialize_for_api(item) }
+        else
+          list.map { |item| type.serialize(item) }
+        end
+      end
+
+      def serialize_for_api(list)
+        serialize(list, enforce_read_only: true)
       end
 
       def type

data/lib/nylas/model.rb

@@ -28,7 +28,7 @@ module Nylas
       result = if persisted?
                  raise ModelNotUpdatableError, self unless updatable?
 
-                 save_call
+                 update_call(attributes.serialize_for_api)
                else
                  create
                end
@@ -120,14 +120,6 @@ module Nylas
 
     private
 
-    def save_call
-      execute(
-        method: :put,
-        payload: attributes.serialize_for_api,
-        path: resource_path
-      )
-    end
-
     def update_call(payload)
       result = execute(
         method: :put,

data/lib/nylas/new_message.rb

@@ -20,6 +20,7 @@ module Nylas
     attribute :subject, :string
     attribute :body, :string
     attribute :reply_to_message_id, :string
+    attribute :metadata, :hash
 
     has_n_of_attribute :file_ids, :string
 

data/lib/nylas/open_hours.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Additional times email accounts are available
+  # @see https://developer.nylas.com/docs/api/#post/calendars/availability
+  class OpenHours
+    include Model::Attributable
+
+    attribute :timezone, :string
+    attribute :start, :string
+    attribute :end, :string
+    has_n_of_attribute :emails, :string
+    has_n_of_attribute :days, :integer
+  end
+end

data/lib/nylas/participant.rb

@@ -7,6 +7,6 @@ module Nylas
     attribute :name, :string
     attribute :email, :string
     attribute :comment, :string
-    attribute :status, :string
+    attribute :status, :string, read_only: true
   end
 end

data/lib/nylas/scheduler.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Ruby representation of a the Nylas Scheduler API
+  # @see https://developer.nylas.com/docs/api/scheduler/#overview
+  class Scheduler
+    include Model
+    self.resources_path = "/manage/pages"
+    allows_operations(creatable: true, listable: true, filterable: true, showable: true, updatable: true,
+                      destroyable: true)
+
+    attribute :id, :integer, read_only: true
+    attribute :app_client_id, :string
+    attribute :app_organization_id, :integer
+    attribute :config, :scheduler_config
+    attribute :edit_token, :string
+    attribute :name, :string
+    attribute :slug, :string
+    attribute :created_at, :date
+    attribute :modified_at, :date
+
+    has_n_of_attribute :access_tokens, :string
+
+    def get_available_calendars
+      raise ArgumentError, "Cannot get calendars for a page without an ID." if id.nil?
+
+      api.execute(
+        method: :get,
+        path: "/manage/pages/#{id}/calendars"
+      )
+    end
+
+    def upload_image(content_type:, object_name:)
+      raise ArgumentError, "Cannot upload an image to a page without an ID." if id.nil?
+
+      payload = {
+        contentType: content_type,
+        objectName: object_name
+      }
+      api.execute(
+        method: :put,
+        path: "/manage/pages/#{id}/upload-image",
+        payload: JSON.dump(payload)
+      )
+    end
+  end
+end

data/lib/nylas/scheduler_booking_confirmation.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent the booking response returned from the Scheduler API
+  class SchedulerBookingConfirmation
+    include Model::Attributable
+    attribute :id, :integer
+    attribute :account_id, :string
+    attribute :calendar_event_id, :string
+    attribute :calendar_id, :string
+    attribute :edit_hash, :string
+    attribute :location, :string
+    attribute :title, :string
+    attribute :recipient_email, :string
+    attribute :recipient_locale, :string
+    attribute :recipient_name, :string
+    attribute :recipient_tz, :string
+    attribute :additional_field_values, :hash
+    attribute :is_confirmed, :boolean
+    attribute :start_time, :unix_timestamp
+    attribute :end_time, :unix_timestamp
+    has_n_of_attribute :additional_emails, :string
+  end
+end

data/lib/nylas/scheduler_booking_request.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent the booking request used for the Scheduler API
+  class SchedulerBookingRequest
+    include Model::Attributable
+    attribute :additional_values, :hash
+    attribute :email, :string
+    attribute :locale, :string
+    attribute :name, :string
+    attribute :page_hostname, :string
+    attribute :replaces_booking_hash, :string
+    attribute :timezone, :string
+    attribute :slot, :scheduler_time_slot
+    has_n_of_attribute :additional_emails, :string
+  end
+end

data/lib/nylas/scheduler_collection.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Additional methods for some of Scheduler's other functionality
+  # @see https://developer.nylas.com/docs/api/scheduler#overview
+  class SchedulerCollection < Collection
+    # Retrieve Google availability
+    # @return [Hash] Returns the availability
+    def get_google_availability
+      execute_provider_availability("google")
+    end
+
+    # Retrieve Office 365 availability
+    # @return [Hash] Returns the availability
+    def get_office_365_availability
+      execute_provider_availability("o365")
+    end
+
+    # Retrieve public config for a scheduling page
+    # @param slug [String] The Scheduler page slug
+    # @return [Scheduler] Returns the Scheduler object representing the page configuration
+    def get_page_slug(slug)
+      page_response = api.execute(
+        method: :get,
+        path: "/schedule/#{slug}/info"
+      )
+
+      Scheduler.new(**page_response.merge(api: api))
+    end
+
+    # Retrieve available time slots
+    # @param slug [String] The Scheduler page slug
+    # @return [Array<SchedulerTimeSlot>] Returns the list of available timeslots
+    def get_available_time_slots(slug)
+      response = api.execute(
+        method: :get,
+        path: "/schedule/#{slug}/timeslots"
+      )
+
+      timeslots = []
+      response.each do |available_slot|
+        timeslots.push(SchedulerTimeSlot.new(**available_slot.merge(api: api)))
+      end
+      timeslots
+    end
+
+    # Book a time slot
+    # @param slug [String] The Scheduler page slug
+    # @param timeslot [SchedulerBookingRequest] The time slot booking request
+    # @return [SchedulerBookingConfirmation] Returns the booking confirmation
+    def book_time_slot(slug, timeslot)
+      payload = timeslot.to_h
+      # The booking endpoint requires additional_values and additional_emails
+      # to exist regardless if they are empty or not
+      payload[:additional_values] = {} unless payload[:additional_values]
+      payload[:additional_emails] = [] unless payload[:additional_emails]
+      booking_response = api.execute(
+        method: :post,
+        path: "/schedule/#{slug}/timeslots",
+        payload: JSON.dump(payload)
+      )
+
+      SchedulerBookingConfirmation.new(**booking_response.merge(api: api))
+    end
+
+    # Cancel a booking
+    # @param slug [String] The Scheduler page slug
+    # @param edit_hash [String] The token used for editing the booked time slot
+    # @param reason [String] The reason for cancelling the booking
+    # @return [Hash] Returns a hash of a boolean representing success of cancellation
+    def cancel_booking(slug, edit_hash, reason)
+      api.execute(
+        method: :post,
+        path: "/schedule/#{slug}/#{edit_hash}/cancel",
+        payload: JSON.dump(reason: reason)
+      )
+    end
+
+    # Confirm a booking
+    # @param slug [String] The Scheduler page slug
+    # @param edit_hash [String] The token used for editing the booked time slot
+    # @return [SchedulerBookingConfirmation] Returns the confirmed booking confirmation
+    def confirm_booking(slug, edit_hash)
+      booking_response = api.execute(
+        method: :post,
+        path: "/schedule/#{slug}/#{edit_hash}/confirm",
+        payload: {}
+      )
+
+      SchedulerBookingConfirmation.new(**booking_response.merge(api: api))
+    end
+
+    private
+
+    # Retrieve provider availability
+    # @return [Hash] Returns the availability
+    def execute_provider_availability(provider)
+      api.execute(
+        method: :get,
+        path: "/schedule/availability/#{provider}"
+      )
+    end
+  end
+end

data/lib/nylas/scheduler_config.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Configuration settings for a Scheduler page
+  # @see https://developer.nylas.com/docs/api/scheduler
+  class SchedulerConfig
+    include Model::Attributable
+
+    attribute :appearance, :hash
+    attribute :booking, :hash
+    attribute :calendar_ids, :hash
+    attribute :event, :hash
+    attribute :expire_after, :hash
+    attribute :locale, :string
+    attribute :locale_for_guests, :string
+    attribute :timezone, :string
+
+    has_n_of_attribute :reminders, :hash
+  end
+end

data/lib/nylas/scheduler_time_slot.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent the time slot object from the Scheduler API
+  class SchedulerTimeSlot
+    include Model::Attributable
+    attribute :account_id, :string
+    attribute :calendar_id, :string
+    attribute :host_name, :string
+    attribute :start, :unix_timestamp
+    attribute :end, :unix_timestamp
+    has_n_of_attribute :emails, :string
+  end
+end

data/lib/nylas/token_info.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Nylas
+  # Structure to represent information about a Nylas access token.
+  # @see https://developer.nylas.com/docs/api/#post/a/client_id/accounts/id/token-info
+  class TokenInfo
+    include Model::Attributable
+
+    attribute :scopes, :string
+    attribute :state, :string
+    attribute :created_at, :unix_timestamp
+    attribute :updated_at, :unix_timestamp
+
+    # Returns the state of the token as a boolean
+    # @return [Boolean] If the token is active
+    def valid?
+      state == "valid"
+    end
+  end
+end

data/lib/nylas/types.rb

@@ -7,8 +7,27 @@ module Nylas
       @registry ||= Registry.new
     end
 
+    # Base type for attributes
+    class ValueType
+      def cast(object)
+        object
+      end
+
+      def serialize(object)
+        object
+      end
+
+      def deseralize(object)
+        object
+      end
+
+      def serialize_for_api(object)
+        serialize(object)
+      end
+    end
+
     # Casts/Serializes data that is persisted and used natively as a Hash
-    class HashType
+    class HashType < ValueType
       def serialize(object)
         object.to_h
       end
@@ -22,10 +41,11 @@ module Nylas
 
     # Type for attributes that are persisted in the API as a hash but exposed in ruby as a particular
     # {Model} or Model-like thing.
-    class ModelType
+    class ModelType < ValueType
       attr_accessor :model
 
       def initialize(model:)
+        super()
         self.model = model
       end
 
@@ -33,6 +53,10 @@ module Nylas
         object.to_h
       end
 
+      def serialize_for_api(object)
+        object&.to_h(enforce_read_only: true)
+      end
+
       def cast(value)
         return model.new if value.nil?
         return value if already_cast?(value)
@@ -56,23 +80,8 @@ module Nylas
       end
     end
 
-    # Type for attributes that do not require casting/serializing/deserializing.
-    class ValueType
-      def cast(object)
-        object
-      end
-
-      def serialize(object)
-        object
-      end
-
-      def deseralize(object)
-        object
-      end
-    end
-
     # Type for attributes represented as a unix timestamp in the API and Time in Ruby
-    class UnixTimestampType
+    class UnixTimestampType < ValueType
       def cast(object)
         return object if object.is_a?(Time) || object.nil?
         return Time.at(object.to_i) if object.is_a?(String)

data/lib/nylas/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Nylas
-  VERSION = "5.4.1"
+  VERSION = "5.7.0"
 end

data/lib/nylas.rb

@@ -35,7 +35,6 @@ require_relative "nylas/model"
 # Attribute types supported by the API
 require_relative "nylas/email_address"
 require_relative "nylas/event"
-require_relative "nylas/event_collection"
 require_relative "nylas/file"
 require_relative "nylas/folder"
 require_relative "nylas/im_address"
@@ -53,14 +52,21 @@ require_relative "nylas/nylas_date"
 require_relative "nylas/when"
 require_relative "nylas/free_busy"
 require_relative "nylas/time_slot"
+require_relative "nylas/open_hours"
 require_relative "nylas/event_conferencing"
 require_relative "nylas/event_conferencing_details"
 require_relative "nylas/event_conferencing_autocreate"
+require_relative "nylas/event_notification"
+require_relative "nylas/component"
 
 # Custom collection types
+require_relative "nylas/event_collection"
 require_relative "nylas/search_collection"
 require_relative "nylas/deltas_collection"
 require_relative "nylas/free_busy_collection"
+require_relative "nylas/calendar_collection"
+require_relative "nylas/component_collection"
+require_relative "nylas/scheduler_collection"
 
 # Models supported by the API
 require_relative "nylas/account"
@@ -77,6 +83,10 @@ require_relative "nylas/new_message"
 require_relative "nylas/raw_message"
 require_relative "nylas/thread"
 require_relative "nylas/webhook"
+require_relative "nylas/scheduler"
+require_relative "nylas/job_status"
+require_relative "nylas/token_info"
+require_relative "nylas/application_details"
 
 # Neural specific types
 require_relative "nylas/neural"
@@ -90,6 +100,10 @@ require_relative "nylas/neural_signature_contact"
 require_relative "nylas/neural_signature_extraction"
 require_relative "nylas/neural_message_options"
 require_relative "nylas/categorize"
+require_relative "nylas/scheduler_config"
+require_relative "nylas/scheduler_time_slot"
+require_relative "nylas/scheduler_booking_request"
+require_relative "nylas/scheduler_booking_confirmation"
 
 require_relative "nylas/native_authentication"
 
@@ -129,9 +143,13 @@ module Nylas
   Types.registry[:event_conferencing] = Types::ModelType.new(model: EventConferencing)
   Types.registry[:event_conferencing_details] = Types::ModelType.new(model: EventConferencingDetails)
   Types.registry[:event_conferencing_autocreate] = Types::ModelType.new(model: EventConferencingAutocreate)
+  Types.registry[:event_notification] = Types::ModelType.new(model: EventNotification)
   Types.registry[:neural] = Types::ModelType.new(model: Neural)
   Types.registry[:categorize] = Types::ModelType.new(model: Categorize)
   Types.registry[:neural_signature_contact] = Types::ModelType.new(model: NeuralSignatureContact)
   Types.registry[:neural_contact_link] = Types::ModelType.new(model: NeuralContactLink)
   Types.registry[:neural_contact_name] = Types::ModelType.new(model: NeuralContactName)
+  Types.registry[:scheduler_config] = Types::ModelType.new(model: SchedulerConfig)
+  Types.registry[:scheduler_time_slot] = Types::ModelType.new(model: SchedulerTimeSlot)
+  Types.registry[:job_status] = Types::ModelType.new(model: JobStatus)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nylas
 version: !ruby/object:Gem::Version
-  version: 5.4.1
+  version: 5.7.0
 platform: ruby
 authors:
 - Nylas, Inc.
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-27 00:00:00.000000000 Z
+date: 2022-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,28 +58,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.52.0
+        version: 1.24.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.52.0
+        version: 1.24.1
 - !ruby/object:Gem::Dependency
   name: rubocop-rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.20.1
+        version: 2.7.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.20.1
+        version: 2.7.0
 - !ruby/object:Gem::Dependency
   name: overcommit
   requirement: !ruby/object:Gem::Requirement
@@ -269,9 +269,13 @@ files:
 - lib/nylas.rb
 - lib/nylas/account.rb
 - lib/nylas/api.rb
+- lib/nylas/application_details.rb
 - lib/nylas/calendar.rb
+- lib/nylas/calendar_collection.rb
 - lib/nylas/categorize.rb
 - lib/nylas/collection.rb
+- lib/nylas/component.rb
+- lib/nylas/component_collection.rb
 - lib/nylas/constraints.rb
 - lib/nylas/contact.rb
 - lib/nylas/contact_group.rb
@@ -287,6 +291,7 @@ files:
 - lib/nylas/event_conferencing.rb
 - lib/nylas/event_conferencing_autocreate.rb
 - lib/nylas/event_conferencing_details.rb
+- lib/nylas/event_notification.rb
 - lib/nylas/file.rb
 - lib/nylas/filter_attributes.rb
 - lib/nylas/folder.rb
@@ -294,6 +299,7 @@ files:
 - lib/nylas/free_busy_collection.rb
 - lib/nylas/http_client.rb
 - lib/nylas/im_address.rb
+- lib/nylas/job_status.rb
 - lib/nylas/label.rb
 - lib/nylas/logging.rb
 - lib/nylas/message.rb
@@ -318,6 +324,7 @@ files:
 - lib/nylas/neural_signature_extraction.rb
 - lib/nylas/new_message.rb
 - lib/nylas/nylas_date.rb
+- lib/nylas/open_hours.rb
 - lib/nylas/participant.rb
 - lib/nylas/phone_number.rb
 - lib/nylas/physical_address.rb
@@ -326,10 +333,17 @@ files:
 - lib/nylas/registry.rb
 - lib/nylas/room_resource.rb
 - lib/nylas/rsvp.rb
+- lib/nylas/scheduler.rb
+- lib/nylas/scheduler_booking_confirmation.rb
+- lib/nylas/scheduler_booking_request.rb
+- lib/nylas/scheduler_collection.rb
+- lib/nylas/scheduler_config.rb
+- lib/nylas/scheduler_time_slot.rb
 - lib/nylas/search_collection.rb
 - lib/nylas/thread.rb
 - lib/nylas/time_slot.rb
 - lib/nylas/timespan.rb
+- lib/nylas/token_info.rb
 - lib/nylas/types.rb
 - lib/nylas/version.rb
 - lib/nylas/web_page.rb
@@ -360,7 +374,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.2.17
 signing_key:
 specification_version: 4
 summary: Gem for interacting with the Nylas API