cronofy 0.0.5 → 0.37.7

data/lib/cronofy/errors.rb

@@ -1,14 +1,11 @@
 module Cronofy
   class CronofyError < StandardError
-
   end
 
   class CredentialsMissingError < CronofyError
-
     def initialize(message=nil)
       super(message || "No credentials supplied")
     end
-
   end
 
   class APIError < CronofyError
@@ -32,28 +29,91 @@ module Cronofy
     end
   end
 
-  class NotFoundError < APIError
+  class BadRequestError < APIError
+  end
 
+  class NotFoundError < APIError
   end
 
   class AuthenticationFailureError < APIError
-
   end
 
   class AuthorizationFailureError < APIError
-
   end
 
   class InvalidRequestError < APIError
+    def message
+      "#{super} - #{errors.inspect}"
+    end
+
+    def errors
+      @errors ||= begin
+        json = JSON.parse(self.body)
+        json.fetch("errors", Hash.new)
+      rescue
+        Hash.new
+      end
+    end
+  end
 
+  class AccountLockedError < APIError
   end
 
   class TooManyRequestsError < APIError
+  end
 
+  class ServerError < APIError
   end
 
-  class UnknownError < APIError
+  class PaymentRequiredError < APIError
+  end
 
+  class ServiceUnreachableError < APIError
   end
 
-end
+  class BadGatewayError < ServiceUnreachableError
+  end
+
+  class ServiceUnavailableError < ServiceUnreachableError
+  end
+
+  class GatewayTimeoutError < ServiceUnreachableError
+  end
+
+  class UnknownError < APIError
+  end
+
+  # Internal: Helper methods for raising more meaningful errors.
+  class Errors
+    ERROR_MAP = {
+      400 => BadRequestError,
+      401 => AuthenticationFailureError,
+      402 => PaymentRequiredError,
+      403 => AuthorizationFailureError,
+      404 => NotFoundError,
+      422 => InvalidRequestError,
+      423 => AccountLockedError,
+      429 => TooManyRequestsError,
+      500 => ServerError,
+      502 => BadGatewayError,
+      503 => ServiceUnavailableError,
+      504 => GatewayTimeoutError,
+    }.freeze
+
+    def self.map_error(error)
+      raise_error(error.response)
+    end
+
+    def self.raise_if_error(response)
+      return if response.status == 200
+      raise_error(response)
+    end
+
+    private
+
+    def self.raise_error(response)
+      error_class = ERROR_MAP.fetch(response.status, UnknownError)
+      raise error_class.new(response.headers['status'], response)
+    end
+  end
+end

data/lib/cronofy/response_parser.rb

@@ -1,13 +1,46 @@
 require 'json'
 
 module Cronofy
+  # Internal: Class for dealing with the parsing of API responses.
   class ResponseParser
     def initialize(response)
       @response = response
     end
 
-    def parse_json
-      JSON.parse @response.body
+    def parse_collections(attribute_collection_types)
+      attribute_collection_types.each do |attribute, type|
+        return parse_collection(type, attribute.to_s) if json_hash[attribute.to_s]
+      end
+
+      raise "No mapped attributes for response - #{json_hash.keys}"
+    end
+
+    def parse_collection(type, attribute = nil)
+      target = parsing_target(attribute)
+      target.map { |item| type.new(item) }
+    end
+
+    def parse_json(type, attribute = nil)
+      target = parsing_target(attribute)
+      type.new(target)
+    end
+
+    def json
+      json_hash.dup
+    end
+
+    private
+
+    def json_hash
+      @json_hash ||= JSON.parse(@response.body)
+    end
+
+    def parsing_target(attribute)
+      if attribute
+        json_hash[attribute]
+      else
+        json_hash
+      end
     end
   end
-end
+end

data/lib/cronofy/time_encoding.rb

@@ -0,0 +1,31 @@
+module Cronofy
+  module TimeEncoding
+    def encode_event_time(value)
+      case value
+      when String
+        value
+      when Hash
+        if value[:time]
+          encoded_time = encode_event_time(value[:time])
+          value.merge(time: encoded_time)
+        else
+          value
+        end
+      else
+        to_iso8601(value)
+      end
+    end
+
+    def to_iso8601(value)
+      case value
+      when NilClass, String
+        value
+      when Time
+        value.getutc.iso8601
+      else
+        value.iso8601
+      end
+    end
+
+  end
+end

data/lib/cronofy/types.rb

@@ -0,0 +1,420 @@
+require "date"
+require "hashie"
+require "time"
+
+module Cronofy
+  class Credentials
+    class LinkingProfile
+      attr_reader :provider_name
+      attr_reader :profile_id
+      attr_reader :profile_name
+
+      def initialize(hash)
+        @provider_name = hash['provider_name'] || hash[:provider_name]
+        @profile_id = hash['profile_id'] || hash[:profile_id]
+        @profile_name = hash['profile_name'] || hash[:profile_name]
+      end
+
+      def to_h
+        {
+          provider_name: provider_name,
+          profile_id: profile_id,
+          profile_name: profile_name,
+        }
+      end
+
+      def ==(other)
+        case other
+        when LinkingProfile
+          self.provider_name == other.provider_name &&
+            self.profile_id == other.profile_id &&
+            self.profile_name == other.profile_name
+        end
+      end
+    end
+
+    attr_reader :access_token
+    attr_reader :account_id
+    attr_reader :application_calendar_id
+    attr_reader :sub
+    attr_reader :expires_at
+    attr_reader :expires_in
+    attr_reader :linking_profile
+    attr_reader :refresh_token
+    attr_reader :scope
+
+    def initialize(oauth_token)
+      @access_token = oauth_token.token
+      @account_id = oauth_token.params['account_id']
+      @application_calendar_id = oauth_token.params['application_calendar_id']
+      @sub = oauth_token.params['sub']
+      @expires_at = oauth_token.expires_at
+      @expires_in = oauth_token.expires_in
+      @refresh_token = oauth_token.refresh_token
+      @scope = oauth_token.params['scope']
+
+      if details = oauth_token.params['linking_profile']
+        @linking_profile = LinkingProfile.new(details)
+      end
+    end
+
+    def to_h
+      hash = {
+        access_token: access_token,
+        expires_at: expires_at,
+        expires_in: expires_in,
+        refresh_token: refresh_token,
+        scope: scope,
+      }
+
+      if account_id
+        hash[:account_id] = account_id
+      end
+
+      if application_calendar_id
+        hash[:application_calendar_id] = application_calendar_id
+      end
+
+      if sub
+        hash[:sub] = sub
+      end
+
+      if linking_profile
+        hash[:linking_profile] = linking_profile.to_h
+      end
+
+      hash
+    end
+
+    def to_hash
+      warn "#to_hash has been deprecated, use #to_h instead"
+      to_h
+    end
+  end
+
+  module ISO8601Time
+    def self.coerce(value)
+      case value
+      when Time
+        value
+      when String
+        Time.iso8601(value)
+      else
+        raise ArgumentError, "Cannot coerce #{value.inspect} to Time"
+      end
+    end
+  end
+
+  class DateOrTime
+    def initialize(args)
+      # Prefer time if both provided as it is more accurate
+      if args[:time]
+        @time = args[:time]
+      else
+        @date = args[:date]
+      end
+    end
+
+    def self.coerce(value)
+      begin
+        time = ISO8601Time.coerce(value)
+      rescue
+        begin
+          date = Date.strptime(value, '%Y-%m-%d')
+        rescue
+        end
+      end
+
+      coerced = self.new(time: time, date: date)
+
+      raise "Failed to coerce \"#{value}\"" unless coerced.time? or coerced.date?
+
+      coerced
+    end
+
+    def date
+      @date
+    end
+
+    def date?
+      !!@date
+    end
+
+    def time
+      @time
+    end
+
+    def time?
+      !!@time
+    end
+
+    def to_date
+      if date?
+        date
+      else
+        time.to_date
+      end
+    end
+
+    def to_time
+      if time?
+        time
+      else
+        # Convert dates to UTC time, not local time
+        Time.utc(date.year, date.month, date.day)
+      end
+    end
+
+    def ==(other)
+      case other
+      when DateOrTime
+        if self.time?
+          other.time? and self.time == other.time
+        elsif self.date?
+          other.date? and self.date == other.date
+        else
+          # Both neither date nor time
+          self.time? == other.time? and self.date? == other.date?
+        end
+      else
+        false
+      end
+    end
+
+    def inspect
+      to_s
+    end
+
+    def to_s
+      if time?
+        "<#{self.class} time=#{self.time}>"
+      elsif date?
+        "<#{self.class} date=#{self.date}>"
+      else
+        "<#{self.class} empty>"
+      end
+    end
+  end
+
+  class CronofyMash < Hashie::Mash
+    include Hashie::Extensions::Coercion
+
+    disable_warnings if respond_to?(:disable_warnings)
+  end
+
+  class Account < CronofyMash
+  end
+
+  BatchEntry = Struct.new(:request, :response)
+
+  class BatchEntryRequest < CronofyMash
+  end
+
+  class BatchEntryResponse < CronofyMash
+  end
+
+  class BatchResponse
+    class PartialSuccessError < CronofyError
+      attr_reader :batch_response
+
+      def initialize(message, batch_response)
+        super(message)
+        @batch_response = batch_response
+      end
+    end
+
+    attr_reader :entries
+
+    def initialize(entries)
+      @entries = entries
+    end
+
+    def errors
+      entries.select { |entry| (entry.status % 100) != 2 }
+    end
+
+    def errors?
+      errors.any?
+    end
+  end
+
+  class UserInfo < CronofyMash
+  end
+
+  class Calendar < CronofyMash
+  end
+
+  class Channel < CronofyMash
+  end
+
+  class Resource < CronofyMash
+  end
+
+  class EventTime
+    attr_reader :time
+    attr_reader :tzid
+
+    def initialize(time, tzid)
+      @time = time
+      @tzid = tzid
+    end
+
+    def self.coerce(value)
+      case value
+      when String
+        DateOrTime.coerce(value)
+      when Hash
+        time_value = value["time"]
+        tzid = value["tzid"]
+
+        date_or_time = DateOrTime.coerce(time_value)
+
+        new(date_or_time, tzid)
+      end
+    end
+
+    def ==(other)
+      case other
+      when EventTime
+        self.time == other.time && self.tzid == other.tzid
+      else
+        false
+      end
+    end
+  end
+
+  class Event < CronofyMash
+    coerce_key :start, EventTime
+    coerce_key :end, EventTime
+
+    coerce_key :created, ISO8601Time
+    coerce_key :updated, ISO8601Time
+  end
+
+  module Events
+    def self.coerce(values)
+      values.map { |v| Event.new(v) }
+    end
+  end
+
+  class PagedEventsResult < CronofyMash
+    coerce_key :events, Events
+  end
+
+  class FreeBusy < CronofyMash
+    coerce_key :start, EventTime
+    coerce_key :end, EventTime
+  end
+
+  module FreeBusyEnumerable
+    def self.coerce(values)
+      values.map { |v| FreeBusy.new(v) }
+    end
+  end
+
+  class PagedFreeBusyResult < CronofyMash
+    coerce_key :free_busy, FreeBusyEnumerable
+  end
+
+  class Profile < CronofyMash
+  end
+
+  class PermissionsResponse < CronofyMash
+  end
+
+  class Participant < CronofyMash
+  end
+
+  class AddToCalendarResponse < CronofyMash
+  end
+
+  class Proposal < CronofyMash
+    coerce_key :start, EventTime
+    coerce_key :end, EventTime
+  end
+
+  class SmartInviteReply < CronofyMash
+    coerce_key :proposal, Proposal
+  end
+
+  module SmartInviteReplyEnumerable
+    def self.coerce(values)
+      values.map { |v| SmartInviteReply.new(v) }
+    end
+  end
+
+  class SmartInviteResponse < CronofyMash
+    coerce_key :recipient, SmartInviteReply
+    coerce_key :replies, SmartInviteReplyEnumerable
+  end
+
+  module ParticipantEnumerable
+    def self.coerce(values)
+      values.map { |v| Participant.new(v) }
+    end
+  end
+
+  class SequenceItem < CronofyMash
+    coerce_key :start, EventTime
+    coerce_key :end, EventTime
+
+    coerce_key :participants, ParticipantEnumerable
+  end
+
+  module SequenceItemEnumerable
+    def self.coerce(values)
+      values.map { |v| SequenceItem.new(v) }
+    end
+  end
+
+  class Sequence < CronofyMash
+    coerce_key :sequence, SequenceItemEnumerable
+  end
+
+  class AvailablePeriod < CronofyMash
+    coerce_key :start, EventTime
+    coerce_key :end, EventTime
+
+    coerce_key :participants, ParticipantEnumerable
+  end
+
+  class AvailableSlot < CronofyMash
+    coerce_key :start, EventTime
+    coerce_key :end, EventTime
+
+    coerce_key :participants, ParticipantEnumerable
+  end
+
+  class ElementToken < CronofyMash
+  end
+
+  class SchedulingConversation < CronofyMash
+  end
+
+  class SchedulingConversationResponse < CronofyMash
+    coerce_key :participant, Participant
+    coerce_key :scheduling_conversation, SchedulingConversation
+  end
+
+  class SchedulingConversationSlot < CronofyMash
+    coerce_key :start, EventTime
+    coerce_key :end, EventTime
+  end
+
+  class WeeklyPeriod < CronofyMash
+  end
+
+  module WeeklyPeriodEnumerable
+    def self.coerce(values)
+      values.map { |v| WeeklyPeriod.new(v) }
+    end
+  end
+
+  class AvailabilityRule < CronofyMash
+    coerce_key :weekly_periods, WeeklyPeriodEnumerable
+  end
+
+  class RealTimeSchedulingStatus < CronofyMash
+    coerce_key :event, Event
+  end
+end

data/lib/cronofy/version.rb

@@ -1,3 +1,3 @@
 module Cronofy
-  VERSION = "0.0.5"
+  VERSION = "0.37.7".freeze
 end

data/lib/cronofy.rb

@@ -1,26 +1,90 @@
 require "cronofy/version"
 require "cronofy/errors"
+require "cronofy/types"
+require "cronofy/api_key"
 require "cronofy/auth"
+require "cronofy/time_encoding"
 require "cronofy/client"
 require "cronofy/response_parser"
+
+require 'base64'
 require 'json'
+require 'openssl'
 
 module Cronofy
+  def self.default_data_centre
+    default_data_center
+  end
+
+  def self.default_data_centre=(value)
+    default_data_center= value
+  end
+
+  def self.default_data_center
+    @default_data_center || ENV['CRONOFY_DATA_CENTER'] || ENV['CRONOFY_DATA_CENTRE']
+  end
+
+  def self.default_data_center=(value)
+    @default_data_center = value
+  end
 
-  def self.api_url
-    @api_url ||= (ENV['CRONOFY_API_URL'] || "https://api.cronofy.com")
+  def self.api_url(data_center_override)
+    if data_center_override
+      api_url_for_data_center(data_center_override)
+    else
+      ENV['CRONOFY_API_URL'] || api_url_for_data_center(default_data_center)
+    end
   end
 
   def self.api_url=(value)
     @api_url = value
   end
 
-  def self.app_url
-    @app_url ||= (ENV['CRONOFY_APP_URL'] || "https://app.cronofy.com")
+  def self.api_url_for_data_centre
+    api_url_for_data_center
+  end
+
+  def self.api_url_for_data_center(dc)
+    @api_urls ||= Hash.new do |hash, key|
+      if key.nil? || key.to_sym == :us
+        url = "https://api.cronofy.com"
+      else
+        url = "https://api-#{key}.cronofy.com"
+      end
+
+      hash[key] = url.freeze
+    end
+
+    @api_urls[dc]
+  end
+
+  def self.app_url(data_center_override)
+    if data_center_override
+      app_url_for_data_center(data_center_override)
+    else
+      ENV['CRONOFY_APP_URL'] || app_url_for_data_center(default_data_center)
+    end
   end
 
   def self.app_url=(value)
     @app_url = value
   end
 
+  def self.app_url_for_data_centre(dc)
+    app_url_for_data_center(dc)
+  end
+
+  def self.app_url_for_data_center(dc)
+    @app_urls ||= Hash.new do |hash, key|
+      if key.nil? || key.to_sym == :us
+        url = "https://app.cronofy.com"
+      else
+        url = "https://app-#{key}.cronofy.com"
+      end
+
+      hash[key] = url.freeze
+    end
+
+    @app_urls[dc]
+  end
 end