nylas_v2 5.14.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 52c4f0f502315cce5b206a8f51117e827bf490b79fbab115c353eea8db6012a8
+  data.tar.gz: ad67ce144b9fbded6bdeff86c88baacb4c132b67cc5614f571d67c836c6f10a6
+SHA512:
+  metadata.gz: dceebf6c7ea48e88b6cc9bc6dcf7f6f7442c9c0d29eb42fcd4b939065a84883e064f69ea8cd1e1693bcc7ca6991258da5dba82f341c0cb6a8f83855304e32230
+  data.tar.gz: 530315f2275117a919ccf410d0c9083ed24ed589ab31981181156deae5daf5af2d76b6a43ed8f486c91488eca21ed49c1fc6e2891c2d13a4c39af33d401484c8

data/lib/nylas_v2/account.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Representation of the accounts for Account management purposes.
+  # @see https://docs.nylas.com/reference#account-management
+  class Account
+    include Model
+    self.listable = true
+    self.showable = true
+    self.updatable = true
+    self.destroyable = true
+    self.filterable = true
+    self.auth_method = HttpClient::AuthMethod::BASIC
+
+    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 :authentication_type, :string, read_only: true
+
+    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")
+      response[:success]
+    end
+
+    def downgrade
+      response = execute(method: :post, path: "#{resource_path}/downgrade")
+      response[:success]
+    end
+
+    def revoke_all(keep_access_token: nil)
+      payload = JSON.dump(keep_access_token: keep_access_token) if keep_access_token
+
+      response = execute(method: :post, path: "#{resource_path}/revoke-all", payload: payload)
+      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
+  end
+end

data/lib/nylas_v2/api.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Methods to retrieve data from the Nylas API as Ruby objects
+  class API
+    attr_accessor :client
+
+    extend Forwardable
+    def_delegators :client, :execute, :get, :post, :put, :delete, :app_id, :api_server
+
+    include Logging
+
+    # @param client [HttpClient] Http Client to use for retrieving data
+    # @param app_id [String] Your application id from the Nylas Dashboard
+    # @param app_secret [String] Your application secret from the Nylas Dashboard
+    # @param access_token [String] (Optional) Your users access token.
+    # @param api_server [String] (Optional) Which Nylas API Server to connect to. Only change this if
+    #                            you're using a self-hosted Nylas instance.
+    # @return [NylasV2::API]
+    def initialize(client: nil, app_id: nil, app_secret: nil, access_token: nil,
+                   api_server: "https://api.nylas.com")
+      self.client = client || HttpClient.new(app_id: app_id, app_secret: app_secret,
+                                             access_token: access_token, api_server: api_server)
+    end
+
+    # @return [String] A Nylas access token for that particular user.
+    def authenticate(name:, email_address:, provider:, settings:, reauth_account_id: nil, scopes: nil)
+      NativeAuthentication.new(api: self).authenticate(
+        name: name,
+        email_address: email_address,
+        provider: provider,
+        settings: settings,
+        reauth_account_id: reauth_account_id,
+        scopes: scopes
+      )
+    end
+
+    def authentication_url(redirect_uri:, scopes:, response_type: "code", login_hint: nil, state: nil,
+                           provider: nil, redirect_on_error: nil, disable_provider_selection: nil)
+      params = { client_id: app_id, redirect_uri: redirect_uri, response_type: response_type,
+                 login_hint: login_hint }
+
+      params[:state] = state if state
+      params[:scopes] = scopes.join(",") if scopes
+      params[:provider] = provider if provider
+      params[:redirect_on_error] = redirect_on_error if redirect_on_error
+      params[:disable_provider_selection] = disable_provider_selection if disable_provider_selection
+
+      "#{api_server}/oauth/authorize?#{URI.encode_www_form(params)}"
+    end
+
+    # 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,
+        "grant_type" => "authorization_code",
+        "code" => code
+      }
+
+      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
+    def contacts
+      @contacts ||= Collection.new(model: Contact, api: self)
+    end
+
+    # @return [Collection<ContactGroup>] A queryable collection of Contact Groups
+    def contact_groups
+      @contact_groups ||= Collection.new(model: ContactGroup, api: self)
+    end
+
+    # @return [CurrentAccount] The account details for whomevers access token is set
+    def current_account
+      prevent_calling_if_missing_access_token(:current_account)
+      CurrentAccount.from_hash(execute(method: :get, path: "/account"), api: self)
+    end
+
+    # @return [Collection<Account>] A queryable collection of {Account}s
+    def accounts
+      @accounts ||= Collection.new(model: Account, api: as(client.app_secret))
+    end
+
+    # @return [CalendarCollection<Calendar>] A queryable collection of {Calendar}s
+    def calendars
+      @calendars ||= CalendarCollection.new(model: Calendar, api: self)
+    end
+
+    # @return [DeltasCollection<Delta>] A queryable collection of Deltas, which are themselves a collection.
+    def deltas
+      @deltas ||= DeltasCollection.new(api: self)
+    end
+
+    # @return[Collection<Draft>] A queryable collection of {Draft} objects
+    def drafts
+      @drafts ||= Collection.new(model: Draft, api: self)
+    end
+
+    # @return [EventCollection<Event>] A queryable collection of {Event}s
+    def events
+      @events ||= EventCollection.new(model: Event, api: self)
+    end
+
+    # @return [Collection<Folder>] A queryable collection of {Folder}s
+    def folders
+      @folders ||= Collection.new(model: Folder, api: self)
+    end
+
+    # @return [Collection<File>] A queryable collection of {File}s
+    def files
+      @files ||= Collection.new(model: File, api: self)
+    end
+
+    # @return [Collection<Label>] A queryable collection of {Label} objects
+    def labels
+      @labels ||= Collection.new(model: Label, api: self)
+    end
+
+    # @return[Collection<Message>] A queryable collection of {Message} objects
+    def messages
+      @messages ||= Collection.new(model: Message, api: self)
+    end
+
+    # @return[Collection<RoomResource>] A queryable collection of {RoomResource} objects
+    def room_resources
+      @room_resources ||= Collection.new(model: RoomResource, api: self)
+    end
+
+    # @return[Collection<JobStatus>] A queryable collection of {JobStatus} objects
+    def job_statuses
+      @job_statuses ||= JobStatusCollection.new(model: JobStatus, api: self)
+    end
+
+    # @return[OutboxCollection] A collection of Outbox operations
+    def outbox
+      @outbox ||= Outbox.new(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 collection of Neural operations
+    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)
+      response = client.as(access_token).post(path: "/oauth/revoke")
+      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}",
+        auth_method: HttpClient::AuthMethod::BASIC
+      )
+      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),
+        auth_method: HttpClient::AuthMethod::BASIC
+      )
+      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)
+    def ip_addresses
+      path = "/a/#{app_id}/ip_addresses"
+      client.as(client.app_secret).get(path: path, auth_method: HttpClient::AuthMethod::BASIC)
+    end
+
+    # @param message [Hash, String, #send!]
+    # @return [Message] The resulting message
+    def send!(message)
+      return message.send! if message.respond_to?(:send!)
+      return NewMessage.new(**message.merge(api: self)).send! if message.respond_to?(:key?)
+      return RawMessage.new(message, api: self).send! if message.is_a? String
+    end
+
+    # Allows you to get an API that acts as a different user but otherwise has the same settings
+    # @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))
+    end
+
+    # @return [Collection<Thread>] A queryable collection of Threads
+    def threads
+      @threads ||= Collection.new(model: Thread, api: self)
+    end
+
+    # @return [Collection<Webhook>] A queryable collection of {Webhook}s
+    def webhooks
+      @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,
+        emails: emails,
+        start_time: start_time.to_i,
+        end_time: end_time.to_i
+      )
+    end
+
+    private
+
+    def prevent_calling_if_missing_access_token(method_name)
+      return if client.access_token && !client.access_token.empty?
+
+      raise NoAuthToken, method_name
+    end
+  end
+end

data/lib/nylas_v2/application_details.rb

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Ruby bindings for the Nylas Calendar API
+  # @see https://docs.nylas.com/reference#calendars
+  class Calendar
+    include Model
+    self.resources_path = "/calendars"
+    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
+    attribute :account_id, :string
+
+    attribute :object, :string
+
+    attribute :name, :string
+    attribute :description, :string
+    attribute :is_primary, :boolean
+    attribute :location, :string
+    attribute :timezone, :string
+
+    attribute :read_only, :boolean
+    attribute :metadata, :hash
+    attribute :job_status_id, :string, read_only: true
+    attribute :hex_color, :string, read_only: true
+
+    def read_only?
+      read_only == true
+    end
+
+    def primary?
+      is_primary
+    end
+
+    def events
+      api.events.where(calendar_id: id)
+    end
+  end
+end

data/lib/nylas_v2/calendar_collection.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Additional methods for some of Calendar's other functionality
+  # @see https://developer.nylas.com/docs/connectivity/calendar
+  class CalendarCollection < Collection
+    # Check multiple calendars to find available time slots for a single meeting
+    # @param duration_minutes [Integer] The total number of minutes the event should last
+    # @param interval_minutes [Integer] How many minutes it should check for availability
+    # @param start_time [Integer] The timestamp for the beginning of the event
+    # @param end_time [Integer] The timestamp for the end of the event
+    # @param emails [Array<String>] Emails on the same domain to check
+    # @param buffer [Integer] The amount of buffer time in minutes that you want around existing meetings
+    # @param round_robin [String] Finds available meeting times in a round-robin style
+    # @param event_collection_id [String] Unique identifier for a collection of events that are created
+    # @param free_busy [Array<NylasV2::FreeBusy>] A list of free-busy data for users not in your organization
+    # @param open_hours [Array<NylasV2::OpenHours>] Additional times email accounts are available
+    # @param calendars [Array] Check account and calendar IDs for free/busy status
+    # @return [Hash] The availability information; a list of time slots where all participants are available
+    def availability(duration_minutes:,
+                     interval_minutes:,
+                     start_time:,
+                     end_time:,
+                     emails: [],
+                     buffer: nil,
+                     round_robin: nil,
+                     event_collection_id: nil,
+                     free_busy: [],
+                     open_hours: [],
+                     calendars: [])
+      validate_calendars_or_emails(calendars, emails)
+      validate_open_hours(emails, free_busy, open_hours) unless open_hours.empty?
+
+      payload = {
+        duration_minutes: duration_minutes,
+        interval_minutes: interval_minutes,
+        start_time: start_time,
+        end_time: end_time,
+        emails: emails,
+        free_busy: free_busy.map(&:to_h),
+        open_hours: open_hours.map(&:to_h),
+        calendars: calendars
+      }
+      payload[:buffer] = buffer if buffer
+      payload[:round_robin] = round_robin if round_robin
+      payload[:event_collection_id] = event_collection_id if event_collection_id
+
+      execute_availability("/calendars/availability", **payload)
+    end
+
+    # Check multiple calendars to find availability for multiple meetings with several participants
+    # @param duration_minutes [Integer] The total number of minutes the event should last
+    # @param interval_minutes [Integer] How many minutes it should check for availability
+    # @param start_time [Integer] The timestamp for the beginning of the event
+    # @param end_time [Integer] The timestamp for the end of the event
+    # @param emails [Array<Array<String>>] Emails on the same domain to check
+    # @param buffer [Integer] The amount of buffer time in minutes that you want around existing meetings
+    # @param free_busy [Array<NylasV2::FreeBusy>] A list of free-busy data for users not in your organization
+    # @param open_hours [Array<NylasV2::OpenHours>] Additional times email accounts are available
+    # @param calendars [Array] Check account and calendar IDs for free/busy status
+    # @return [Hash] The availability information; a list of all possible groupings that share time slots
+    def consecutive_availability(duration_minutes:,
+                                 interval_minutes:,
+                                 start_time:,
+                                 end_time:,
+                                 emails: [],
+                                 buffer: nil,
+                                 free_busy: [],
+                                 open_hours: [],
+                                 calendars: [])
+      validate_calendars_or_emails(emails, calendars)
+      validate_open_hours(emails, free_busy, open_hours) unless open_hours.empty?
+
+      payload = {
+        duration_minutes: duration_minutes,
+        interval_minutes: interval_minutes,
+        start_time: start_time,
+        end_time: end_time,
+        emails: emails,
+        free_busy: free_busy.map(&:to_h),
+        open_hours: open_hours.map(&:to_h),
+        calendars: calendars
+      }
+      payload[:buffer] = buffer if buffer
+
+      execute_availability("/calendars/availability/consecutive", **payload)
+    end
+
+    private
+
+    def execute_availability(path, **payload)
+      api.execute(
+        method: :post,
+        path: path,
+        payload: JSON.dump(payload)
+      )
+    end
+
+    def validate_calendars_or_emails(calendars, emails)
+      return unless calendars.empty? && emails.empty?
+
+      raise ArgumentError, "You must provide at least one of 'emails' or 'calendars'"
+    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_v2/categorize.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module NylasV2
+  # Structure to represent the Neural Categorize object.
+  # @see https://developer.nylas.com/docs/intelligence/categorizer/#categorize-message-response
+  class Categorize
+    include Model::Attributable
+
+    attribute :category, :string
+    attribute :categorized_at, :unix_timestamp
+    attribute :model_version, :string
+    has_n_of_attribute :subcategories, :string
+  end
+end