nylas 5.17.0 → 6.0.3

data/lib/nylas/constraints.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # The constraints a particular GET request will include in their query params
-  class Constraints
-    attr_accessor :where, :limit, :offset, :view, :per_page, :accept
-
-    def initialize(where: {}, limit: nil, offset: 0, view: nil, per_page: 100, accept: "application/json")
-      self.where = where
-      self.limit = limit
-      self.offset = offset
-      self.view = view
-      self.per_page = per_page
-      self.accept = accept
-    end
-
-    def merge(where: {}, limit: nil, offset: nil, view: nil, per_page: nil, accept: nil)
-      Constraints.new(where: self.where.merge(where),
-                      limit: limit || self.limit,
-                      per_page: per_page || self.per_page,
-                      offset: offset || self.offset,
-                      view: view || self.view,
-                      accept: accept || self.accept)
-    end
-
-    def next_page
-      merge(offset: offset + per_page)
-    end
-
-    def to_query
-      query = where.each_with_object({}) do |(name, value), result|
-        result[name] = value
-      end
-      query[:limit] = limit_for_query
-      query[:offset] = offset unless offset.nil?
-      query[:view] = view unless view.nil?
-      query
-    end
-
-    def to_headers
-      accept == "application/json" ? {} : { "Accept" => accept, "Content-types" => accept }
-    end
-
-    def limit_for_query
-      !limit.nil? && limit < per_page ? limit : per_page
-    end
-
-    def self.from_constraints(constraints = Constraints.new)
-      return constraints if constraints.is_a?(Constraints)
-      return new(**constraints) if constraints.respond_to?(:key?)
-      return new if constraints.nil?
-
-      raise TypeError, "passed in constraints #{constraints} cannot be cast to a set of constraints"
-    end
-  end
-end

data/lib/nylas/contact.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # ActiveModel compliant interface for interacting with the Contacts API
-  # @see https://docs.nylas.com/reference#contacts
-  class Contact
-    include Model
-    self.resources_path = "/contacts"
-    self.creatable = true
-    self.listable = true
-    self.showable = true
-    self.filterable = true
-    self.updatable = true
-    self.destroyable = true
-
-    attribute :id, :string, read_only: true
-    attribute :object, :string, default: "contact"
-    attribute :account_id, :string, read_only: true
-
-    attribute :given_name, :string
-    attribute :middle_name, :string
-    attribute :picture_url, :string
-    attribute :surname, :string
-    attribute :birthday, :string
-    attribute :suffix, :string
-    attribute :nickname, :string
-    attribute :company_name, :string
-    attribute :job_title, :string
-    attribute :manager_name, :string
-    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
-    has_n_of_attribute :im_addresses, :im_address
-    has_n_of_attribute :physical_addresses, :physical_address
-    has_n_of_attribute :phone_numbers, :phone_number
-    has_n_of_attribute :web_pages, :web_page
-
-    # @returns [Tempfile] path to the retrieved picture. It is preferrable to cache this in your system than
-    # to retrieve it from nylas every time.
-    def picture
-      return @picture_tempfile if @picture_tempfile
-
-      @picture_tempfile = Tempfile.new
-      @picture_tempfile.write(api.get(path: "#{resource_path}/picture"))
-      @picture_tempfile.close
-      @picture_tempfile
-    end
-  end
-end

data/lib/nylas/contact_group.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Structure to represent the Contact Group schema
-  # @see https://docs.nylas.com/reference#contactsid
-  class ContactGroup
-    include Model
-    self.resources_path = "/contacts/groups"
-
-    self.creatable = false
-    self.destroyable = false
-    self.filterable = false
-    self.listable = true
-    self.showable = false
-    self.updatable = false
-
-    attribute :id, :string
-    attribute :object, :string
-    attribute :account_id, :string
-    attribute :name, :string
-    attribute :path, :string
-  end
-end

data/lib/nylas/current_account.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Ruby representation of the Nylas /account API
-  # @see https://docs.nylas.com/reference#account
-  class CurrentAccount
-    include Model
-    self.showable = true
-
-    self.resources_path = "/account"
-
-    attribute :id, :string
-    attribute :object, :string, default: "account"
-
-    attribute :account_id, :string
-    attribute :email_address, :string
-    attribute :name, :string
-    attribute :organization_unit, :string
-    attribute :provider, :string
-    attribute :sync_state, :string
-    attribute :linked_at, :unix_timestamp
-  end
-end

data/lib/nylas/delta.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Ruby object to represent a single change. Used both when receiving a webhook, as well as the deltas API.
-  # @see https://docs.nylas.com/reference#receiving-notifications
-  # @see https://docs.nylas.com/reference#deltas
-  class Delta
-    include Model::Attributable
-
-    attribute :id, :string
-    attribute :type, :string
-    attribute :object, :string
-    attribute :event, :string
-    attribute :cursor, :string
-    attribute :namespace_id, :string
-    attribute :account_id, :string
-
-    attribute :headers, :message_headers
-
-    attribute :date, :unix_timestamp
-    attribute :metadata, :hash
-    attribute :object_attributes, :hash
-
-    def model
-      return nil if object.nil?
-
-      @model ||= Types.registry[object.to_sym].cast(object_attributes_with_ids)
-    end
-
-    private
-
-    def object_attributes_with_ids
-      (object_attributes || {}).merge(id: id, account_id: account_id)
-    end
-  end
-
-  # Casts Delta data from either a webhook or a delta stream to a Delta
-  class DeltaType < Types::ModelType
-    def initialize
-      super(model: Delta)
-    end
-
-    def cast(data)
-      data = if data.key?(:object_data)
-               object_data = data.delete(:object_data)
-               data.merge(object_data)
-             else
-               data
-             end
-
-      data = data.merge(data[:attributes]) if data[:attributes]
-      data[:object_attributes] = data.delete(:attributes)
-      super(**data)
-    end
-  end
-end

data/lib/nylas/deltas.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Ruby object to represent a collection of changes. Used both when receiving a webhook, as well as the
-  # deltas API.
-  # @see https://docs.nylas.com/reference#receiving-notifications
-  # @see https://docs.nylas.com/reference#deltas
-  class Deltas
-    include Model
-    self.resources_path = "/delta"
-    self.filterable = true
-    has_n_of_attribute :deltas, :delta
-    attribute :cursor_start, :string
-    attribute :cursor_end, :string
-
-    extend Forwardable
-    def_delegators :deltas, :count, :length, :each, :map, :first, :last, :to_a, :empty?
-  end
-end

data/lib/nylas/deltas_collection.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Special collection for delta objects
-  class DeltasCollection < Collection
-    attr_accessor :deltas
-
-    extend Forwardable
-    def_delegators :execute, :cursor_start, :cursor_end,
-                   :count, :each, :to_h, :to_a, :empty?
-
-    def initialize(api:, constraints: nil, model: Deltas)
-      super(api: api, model: model, constraints: constraints)
-    end
-
-    def latest_cursor
-      api.execute(method: :post, path: "#{resources_path}/latest_cursor")[:cursor]
-    end
-
-    def latest
-      since(latest_cursor)
-    end
-
-    def since(cursor)
-      where(cursor: cursor)
-    end
-
-    def next_page(*)
-      return nil if empty?
-
-      where(cursor: cursor_end)
-    end
-
-    # Retrieves the data from the API for the particular constraints
-    # @return [Detlas]
-    def execute
-      self.deltas ||= Deltas.new(**api.execute(**to_be_executed))
-    end
-  end
-end

data/lib/nylas/draft.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Ruby representatin of a Nylas Draft object
-  # @see https://docs.nylas.com/reference#drafts
-  class Draft
-    include Model
-    self.resources_path = "/drafts"
-    self.creatable = true
-    self.listable = true
-    self.showable = true
-    self.updatable = true
-    self.destroyable = true
-    self.id_listable = true
-    self.countable = true
-
-    attribute :id, :string
-    attribute :object, :string
-    attribute :version, :integer
-    attribute :account_id, :string
-    attribute :thread_id, :string
-    attribute :reply_to_message_id, :string
-
-    has_n_of_attribute :to, :email_address
-    has_n_of_attribute :from, :email_address
-    has_n_of_attribute :cc, :email_address
-    has_n_of_attribute :bcc, :email_address
-    has_n_of_attribute :reply_to, :email_address
-
-    attribute :date, :unix_timestamp
-    attribute :subject, :string
-    attribute :snippet, :string
-    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
-    has_n_of_attribute :file_ids, :string
-    attribute :folder, :folder
-    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]
-
-    def update(**data)
-      # If files are provided, replace files with file IDs
-      self.files = data[:files] if data[:files]
-      extract_file_ids!
-      data[:file_ids] = file_ids
-      # If version is not provided, add version or request will fail
-      data[:version] = version unless data[:version]
-
-      super
-    end
-
-    def create
-      extract_file_ids!
-
-      super
-    end
-
-    def send!
-      return execute(method: :post, path: "/send", payload: to_json) unless id
-
-      data = { draft_id: id, version: version }
-      data[:tracking] = tracking.to_h if tracking
-      execute(method: :post, path: "/send", payload: JSON.dump(data))
-    end
-
-    def starred?
-      starred
-    end
-
-    def unread?
-      unread
-    end
-
-    def destroy
-      execute(method: :delete, path: resource_path, payload: attributes.serialize_for_api(keys: [:version]))
-    end
-
-    def save
-      extract_file_ids!
-
-      super
-    end
-
-    private
-
-    def extract_file_ids!
-      files = self.files || []
-
-      self.file_ids ||= files.map(&:id)
-    end
-  end
-end

data/lib/nylas/email_address.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Structure to represent the Email Address Schema
-  # @see https://docs.nylas.com/reference#contactsid
-  class EmailAddress
-    include Model::Attributable
-    attribute :type, :string
-    attribute :email, :string
-    attribute :name, :string
-  end
-end

data/lib/nylas/event.rb

@@ -1,144 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Structure to represent a the Event Schema.
-  # @see https://docs.nylas.com/reference#events
-  class Event
-    include Model
-    self.resources_path = "/events"
-    self.creatable = true
-    self.listable = true
-    self.showable = true
-    self.filterable = true
-    self.updatable = true
-    self.destroyable = true
-    self.id_listable = true
-    self.countable = true
-
-    attribute :id, :string, read_only: true
-    attribute :object, :string, read_only: true
-    attribute :account_id, :string, read_only: true
-    attribute :calendar_id, :string
-    attribute :master_event_id, :string
-    attribute :message_id, :string
-    attribute :ical_uid, :string
-    attribute :event_collection_id, :string
-
-    attribute :capacity, :integer
-    attribute :busy, :boolean
-    attribute :description, :string
-    attribute :location, :string
-    attribute :owner, :string
-    attribute :recurrence, :recurrence
-    has_n_of_attribute :participants, :participant
-    attribute :read_only, :boolean
-    attribute :status, :string
-    attribute :title, :string
-    attribute :when, :when
-    attribute :metadata, :hash
-    attribute :conferencing, :event_conferencing
-    has_n_of_attribute :notifications, :event_notification
-    has_n_of_attribute :round_robin_order, :string
-    attribute :original_start_time, :unix_timestamp
-    attribute :organizer_email, :string
-    attribute :organizer_name, :string
-    attribute :reminder_minutes, :string
-    attribute :reminder_method, :string
-    attribute :job_status_id, :string, read_only: true
-    attribute :visibility, :string
-    attribute :updated_at, :unix_timestamp, read_only: true
-
-    attr_accessor :notify_participants
-
-    def busy?
-      busy
-    end
-
-    def read_only?
-      read_only
-    end
-
-    def save
-      validate
-      format_reminder_minutes
-
-      super
-    end
-
-    def rsvp(status, notify_participants:)
-      rsvp = Rsvp.new(api: api, status: status, notify_participants: notify_participants,
-                      event_id: id, account_id: account_id)
-      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 validate
-      if conferencing
-        body = to_h
-        if body.dig(:conferencing, :details) && body.dig(:conferencing, :autocreate)
-          raise ArgumentError, "Cannot set both 'details' and 'autocreate' in conferencing object."
-        end
-      end
-      return unless capacity && capacity != -1 && participants && participants.length > capacity
-
-      raise ArgumentError, "The number of participants in the event exceeds the set capacity."
-    end
-
-    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
-
-    # Formats the reminder minute field to match the API format: "[%d]"
-    def format_reminder_minutes
-      return if reminder_minutes.nil? || reminder_minutes.empty? || reminder_minutes.match(/\[\d+\]/)
-
-      self.reminder_minutes = "[#{reminder_minutes}]"
-    end
-
-    def query_params
-      if notify_participants.nil?
-        {}
-      else
-        {
-          notify_participants: notify_participants
-        }
-      end
-    end
-  end
-end

data/lib/nylas/event_collection.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Syntactical sugar methods for some of the Event's filters
-  # @see https://docs.nylas.com/reference#get-events
-  class EventCollection < Collection
-    def expand_recurring
-      where(expand_recurring: true)
-    end
-
-    def show_cancelled
-      where(show_cancelled: true)
-    end
-  end
-end

data/lib/nylas/event_conferencing.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Structure to represent the Event Conferencing object
-  # @see https://developer.nylas.com/docs/connectivity/calendar/conference-sync-beta
-  class EventConferencing
-    include Model::Attributable
-    attribute :provider, :string
-    attribute :details, :event_conferencing_details
-    attribute :autocreate, :event_conferencing_autocreate
-  end
-end

data/lib/nylas/event_conferencing_autocreate.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Structure to represent the autocreate object within the Event Conferencing object
-  # @see https://developer.nylas.com/docs/connectivity/calendar/conference-sync-beta
-  class EventConferencingAutocreate
-    include Model::Attributable
-    attribute :settings, :hash, default: {}
-  end
-end

data/lib/nylas/event_conferencing_details.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Structure to represent the details object within the Event Conferencing object
-  # @see https://developer.nylas.com/docs/connectivity/calendar/conference-sync-beta
-  class EventConferencingDetails
-    include Model::Attributable
-    attribute :meeting_code, :string
-    attribute :password, :string
-    attribute :pin, :string
-    attribute :url, :string
-    has_n_of_attribute :phone, :string
-  end
-end

data/lib/nylas/event_notification.rb

@@ -1,17 +0,0 @@
-# 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

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Structure to represent a the File Schema.
-  # @see https://docs.nylas.com/reference#events
-  class File
-    include Model
-    self.resources_path = "/files"
-    self.creatable = true
-    self.listable = true
-    self.showable = true
-    self.filterable = true
-    self.destroyable = true
-    self.id_listable = true
-    self.countable = true
-
-    attribute :id, :string
-    attribute :account_id, :string
-    attribute :content_id, :string
-    has_n_of_attribute :message_ids, :string
-
-    attribute :object, :string
-
-    attribute :content_type, :string
-    attribute :filename, :string
-    attribute :size, :integer
-    attribute :content_disposition, :string
-
-    attr_accessor :file
-
-    # Downloads and caches a local copy of the file.
-    # @return [Tempfile] - Local copy of the file
-    def download
-      return file if file
-
-      self.file = retrieve_file
-    end
-
-    # Redownloads a file even if it's been cached. Closes and unlinks the tempfile to help memory usage.
-    def download!
-      return download if file.nil?
-
-      file.close
-      file.unlink
-      self.file = nil
-      download
-    end
-
-    def create
-      save
-    end
-
-    def save
-      raise ModelNotUpdatableError if persisted?
-
-      response = api.execute(path: "/files", method: :post, headers: { multipart: true },
-                             payload: { file: file })
-      attributes.merge(response.first)
-      true
-    end
-
-    private
-
-    def retrieve_file
-      response = api.get(path: "#{resource_path}/download")
-      filename = response.headers.fetch(:content_disposition, "").gsub("attachment; filename=", "")
-      # The returned filename can be longer than 256 chars which isn't supported by rb_sysopen.
-      # 128 chars here is more than enough given that TempFile ensure the filename will be unique.
-      temp_file = Tempfile.new(filename[0..127], encoding: "ascii-8bit")
-      temp_file.write(response.body)
-      temp_file.seek(0)
-      temp_file
-    end
-  end
-end