nylas_v2 5.14.2

data/lib/nylas_v2/scheduler_collection.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # 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_v2/scheduler_config.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # 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_v2/scheduler_time_slot.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # 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_v2/search_collection.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Ensures our search requests hit the right path
+  class SearchCollection < Collection
+    def resources_path
+      "#{model.resources_path(api: api)}/search"
+    end
+  end
+end

data/lib/nylas_v2/send_grid_verified_status.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Ruby representation of a Nylas Send Grid verified status object
+  # @see https://docs.nylas.com/reference#drafts
+  class SendGridVerifiedStatus
+    include Model::Attributable
+
+    attribute :domain_verified, :boolean
+    attribute :sender_verified, :boolean
+  end
+end

data/lib/nylas_v2/thread.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Ruby representation of the Nylas /threads API
+  # @see https://docs.nylas.com/reference#threads
+  class Thread
+    include Model
+    self.searchable = true
+    self.listable = true
+    self.filterable = true
+    self.updatable = true
+    self.id_listable = true
+    self.countable = true
+
+    self.resources_path = "/threads"
+
+    attribute :id, :string
+    attribute :object, :string
+    attribute :account_id, :string
+    has_n_of_attribute :draft_ids, :string
+    attribute :first_message_timestamp, :unix_timestamp
+    attribute :has_attachments, :boolean
+
+    attribute :last_message_timestamp, :unix_timestamp
+    attribute :last_message_received_timestamp, :unix_timestamp
+    attribute :last_message_sent_timestamp, :unix_timestamp
+
+    has_n_of_attribute :labels, :label
+    has_n_of_attribute :folders, :folder
+    has_n_of_attribute :message_ids, :string
+    has_n_of_attribute :messages, :message
+    has_n_of_attribute :participants, :participant
+    attribute :snippet, :string
+    attribute :starred, :boolean
+    attribute :subject, :string
+    attribute :unread, :boolean
+    attribute :version, :integer
+    attribute :folder_id, :string
+
+    has_n_of_attribute :label_ids, :string
+
+    transfer :api, to: %i[labels folders]
+
+    UPDATABLE_ATTRIBUTES = %i[label_ids folder_id starred unread].freeze
+    def update(data)
+      unupdatable_attributes = data.keys.reject { |name| UPDATABLE_ATTRIBUTES.include?(name) }
+      unless unupdatable_attributes.empty?
+        raise ArgumentError, "Cannot update #{unupdatable_attributes} only " \
+                             "#{UPDATABLE_ATTRIBUTES} are updatable"
+      end
+      super(**data)
+    end
+
+    def update_folder(folder_id)
+      update(folder_id: folder_id)
+    end
+
+    def starred?
+      starred
+    end
+
+    def unread?
+      unread
+    end
+  end
+end

data/lib/nylas_v2/time_slot.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Query free/busy information for a calendar during a certain time period
+  # @see https://docs.nylas.com/reference#calendars-free-busy
+  class TimeSlot
+    include Model::Attributable
+
+    attribute :object, :string
+    attribute :status, :string
+    attribute :start_time, :unix_timestamp
+    attribute :end_time, :unix_timestamp
+    attribute :capacity, :time_slot_capacity
+    has_n_of_attribute :emails, :string
+  end
+end

data/lib/nylas_v2/time_slot_capacity.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Capacity values for a timeslot
+  # @see https://docs.nylas.com/reference#calendars-free-busy
+  class TimeSlotCapacity
+    include Model::Attributable
+
+    attribute :event_id, :string
+    attribute :current_capacity, :integer
+    attribute :max_capacity, :integer
+  end
+end

data/lib/nylas_v2/timespan.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Structure to represent a Nylas Timespan.
+  # @see https://docs.nylas.com/reference#section-timespan
+  class Timespan
+    extend Forwardable
+
+    include Model::Attributable
+    attribute :object, :string
+    attribute :start_time, :unix_timestamp
+    attribute :end_time, :unix_timestamp
+
+    def_delegators :range, :cover?
+
+    def range
+      @range ||= Range.new(start_time, end_time)
+    end
+  end
+end

data/lib/nylas_v2/token_info.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # 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_v2/types.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Collection of attribute types
+  module Types
+    def self.registry
+      @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 < ValueType
+      def serialize(object)
+        object.to_h
+      end
+
+      def cast(value)
+        return JSON.parse(value, symbolize_names: true) if value.is_a?(String)
+        return value if value.respond_to?(:key)
+      end
+    end
+    Types.registry[:hash] = HashType.new
+
+    # 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 < ValueType
+      attr_accessor :model
+
+      def initialize(model:)
+        super()
+        self.model = model
+      end
+
+      def serialize(object)
+        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)
+        return model.new(**actual_attributes(value)) if value.respond_to?(:key?)
+
+        raise TypeError, "Unable to cast #{value} to a #{model}"
+      end
+
+      def already_cast?(value)
+        model.attribute_definitions.keys.all? { |attribute_name| value.respond_to?(attribute_name) }
+      end
+
+      def actual_attributes(hash)
+        model.attribute_definitions.keys.each_with_object({}) do |attribute_name, attributes|
+          attributes[attribute_name] = hash[json_key_from_attribute_name(attribute_name)]
+        end
+      end
+
+      def json_key_from_attribute_name(name)
+        name
+      end
+    end
+
+    # Type for attributes represented as a unix timestamp in the API and Time in Ruby
+    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)
+        return Time.at(object) if object.is_a?(Numeric)
+        return object.to_time if object.is_a?(Date)
+
+        raise TypeError, "Unable to cast #{object} to Time"
+      end
+
+      def deserialize(object)
+        cast(object)
+      end
+
+      def serialize(object)
+        return nil if object.nil?
+
+        object.to_i
+      end
+    end
+    Types.registry[:unix_timestamp] = UnixTimestampType.new
+
+    # Type for attributes represented as an iso8601 dates in the API and Date in Ruby
+    class DateType < ValueType
+      def cast(value)
+        return nil if value.nil?
+
+        Date.parse(value)
+      end
+
+      def serialize(value)
+        return value.iso8601 if value.respond_to?(:iso8601)
+
+        value
+      end
+    end
+    Types.registry[:date] = DateType.new
+
+    # Type for attributes represented as pure strings both within the API and in Ruby
+    class StringType < ValueType
+      # @param value [Object] Casts the passed in object to a string using #to_s
+      def cast(value)
+        return value if value.nil?
+
+        value.to_s
+      end
+    end
+    Types.registry[:string] = StringType.new
+
+    # Type for attributes represented as pure integers both within the API and in Ruby
+    class IntegerType < ValueType
+      # @param value [Object] Casts the passed in object to an integer using to_i
+      def cast(value)
+        return nil if value.nil?
+
+        value.to_i
+      end
+    end
+    Types.registry[:integer] = IntegerType.new
+
+    # Type for attributes represented as booleans.
+    class BooleanType < ValueType
+      # @param value [Object] Strictly casts the passed in value to a boolean (must be true, not "" or 1)
+      def cast(value)
+        return nil if value.nil?
+        return true if value == true
+        return false if value == false
+
+        raise TypeError, "#{value} must be either true or false"
+      end
+    end
+    Types.registry[:boolean] = BooleanType.new
+
+    # Type for attributes represented as floats.
+    class FloatType < ValueType
+      # @param value [Object] Strictly casts the passed in value to a boolean (must be true, not "" or 1)
+      def cast(value)
+        return nil if value.nil?
+
+        value.to_f
+      end
+    end
+    Types.registry[:float] = FloatType.new
+  end
+end

data/lib/nylas_v2/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module NylasV2
+  VERSION = "5.14.2"
+end

data/lib/nylas_v2/web_page.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Structure to represent the Web Page Schema
+  # @see https://docs.nylas.com/reference#contactsid
+  class WebPage
+    include Model::Attributable
+    attribute :type, :string
+    attribute :url, :string
+  end
+end

data/lib/nylas_v2/webhook.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module WebhookState
+  # Module representing the possible 'state' values in a Webhook
+  # @see https://developer.nylas.com/docs/api#post/a/client_id/webhooks
+
+  ACTIVE = "active"
+  INACTIVE = "inactive"
+end
+
+module WebhookTrigger
+  # Module representing the possible 'trigger' values in a Webhook
+  # @see https://developer.nylas.com/docs/api#post/a/client_id/webhooks
+
+  ACCOUNT_CONNECTED = "account.connected"
+  ACCOUNT_RUNNING = "account.running"
+  ACCOUNT_STOPPED = "account.stopped"
+  ACCOUNT_INVALID = "account.invalid"
+  ACCOUNT_SYNC_ERROR = "account.sync_error"
+  MESSAGE_CREATED = "message.created"
+  MESSAGE_OPENED = "message.opened"
+  MESSAGE_LINK_CLICKED = "message.link_created"
+  MESSAGE_UPDATED = "message.updated"
+  MESSAGE_BOUNCED = "message.bounced"
+  THREAD_REPLIED = "thread.replied"
+  CONTACT_CREATED = "contact.created"
+  CONTACT_UPDATED = "contact.updated"
+  CONTACT_DELETED = "contact.deleted"
+  CALENDAR_CREATED = "calendar.created"
+  CALENDAR_UPDATED = "calendar.updated"
+  CALENDAR_DELETED = "calendar.deleted"
+  EVENT_CREATED = "event.created"
+  EVENT_UPDATED = "event.updated"
+  EVENT_DELETED = "event.deleted"
+  JOB_SUCCESSFUL = "job.successful"
+  JOB_FAILED = "job.failed"
+end
+
+module NylasV2
+  # Represents a webhook attached to your application.
+  # @see https://docs.nylas.com/reference#webhooks
+  class Webhook
+    include Model
+    self.creatable = true
+    self.listable = true
+    self.showable = true
+    self.updatable = true
+    self.destroyable = true
+    self.auth_method = HttpClient::AuthMethod::BASIC
+    attribute :id, :string, read_only: true
+    attribute :application_id, :string, read_only: true
+
+    attribute :callback_url, :string
+    attribute :state, :string
+    attribute :version, :string, read_only: true
+    has_n_of_attribute :triggers, :string
+
+    STATE = [:inactive].freeze
+
+    def save
+      result = if persisted?
+                 update_call(update_payload)
+               else
+                 create
+               end
+
+      attributes.merge(result)
+    end
+
+    def save_all_attributes
+      save
+    end
+
+    def update(**data)
+      raise ArgumentError, "Only 'state' is allowed to be updated" if data.length > 1 || !data.key?(:state)
+
+      attributes.merge(**data)
+      payload = JSON.dump(data)
+      update_call(payload)
+
+      true
+    end
+
+    def update_all_attributes(**data)
+      update(**data)
+    end
+
+    def self.resources_path(api:)
+      "/a/#{api.app_id}/webhooks"
+    end
+
+    private
+
+    def update_payload
+      JSON.dump({ state: state })
+    end
+  end
+end

data/lib/nylas_v2/when.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module NylasV2
+  require "tzinfo"
+
+  # Structure to represent all the Nylas time types.
+  # @see https://docs.nylas.com/reference#section-time
+  class When
+    extend Forwardable
+
+    include Model::Attributable
+
+    attribute :object, :string, read_only: true
+
+    # when object == 'date'
+    attribute :date, :date
+
+    # when object == 'datespan'
+    attribute :start_date, :date
+    attribute :end_date, :date
+
+    # when object == 'time'
+    attribute :time, :unix_timestamp
+    # Timezone must be set to a valid IANA database timezone name
+    attribute :timezone, :string
+
+    # when object == 'timespan'
+    attribute :start_time, :unix_timestamp
+    attribute :end_time, :unix_timestamp
+    # Both timezone fields must be set to a valid IANA database timezone name
+    attribute :start_timezone, :string
+    attribute :end_timezone, :string
+
+    def_delegators :range, :cover?
+
+    def as_timespan
+      return unless object == "timespan"
+
+      Timespan.new(object: object, start_time: start_time, end_time: end_time)
+    end
+
+    def range
+      case object
+      when "timespan"
+        Range.new(start_time, end_time)
+      when "datespan"
+        Range.new(start_date, end_date)
+      when "date"
+        Range.new(date, date)
+      when "time"
+        Range.new(time, time)
+      end
+    end
+
+    # Validates the When object
+    # @return [Boolean] True if the When is valid
+    # @raise [ArgumentError] If any of the timezone fields are not valid IANA database names
+    def valid?
+      validate_timezone(timezone) if timezone
+      validate_timezone(start_timezone) if start_timezone
+      validate_timezone(end_timezone) if end_timezone
+
+      true
+    end
+
+    private
+
+    def validate_timezone(timezone_var)
+      return if TZInfo::Timezone.all_identifiers.include?(timezone_var)
+
+      raise ArgumentError,
+            format("The timezone provided (%s) is not a valid IANA timezone database name", timezone_var)
+    end
+  end
+end