wix-hive-ruby 0.9.0

data/lib/hive/connect/response/parse_json.rb

@@ -0,0 +1,29 @@
+require 'faraday'
+require 'json'
+
+module Hive
+  module Response
+    class ParseJson < Faraday::Response::Middleware
+      WHITESPACE_REGEX = /\A^\s*$\z/
+
+      def on_complete(response)
+        response.body = parse(response.body) if respond_to?(:parse) && !unparsable_status_codes.include?(response.status)
+      end
+
+      def parse(body)
+        case body
+        when WHITESPACE_REGEX, nil
+          nil
+        else
+          JSON.parse(body, symbolize_names: true)
+        end
+      end
+
+      def unparsable_status_codes
+        [204, 301, 302, 304]
+      end
+    end
+  end
+end
+
+Faraday::Response.register_middleware parse_json: Hive::Response::ParseJson

data/lib/hive/connect/response/raise_error.rb

@@ -0,0 +1,17 @@
+require 'faraday'
+
+module Hive
+  module Response
+    class RaiseError < Faraday::Response::Middleware
+      def on_complete(response)
+        status_code = response.status.to_i
+        klass = Hive::Response::Error.errors[status_code]
+        return unless klass
+        error = klass.from_response(response)
+        fail(error)
+      end
+    end
+  end
+end
+
+Faraday::Response.register_middleware raise_error: Hive::Response::RaiseError

data/lib/hive/connect/wix_client.rb

@@ -0,0 +1,148 @@
+require 'hive/connect/request/wix_api_request'
+require 'hive/rest/api'
+require 'faraday'
+require 'faraday_middleware'
+require 'faraday/request/multipart'
+require 'json'
+require 'timeout'
+require 'hive/connect/response/parse_json'
+require 'hive/connect/response/raise_error'
+require 'hive/connect/response/error'
+require 'hive/version'
+require 'logger'
+
+module Hive
+  class Client
+    include Hive::REST::API
+
+    attr_accessor :secret_key, :app_id, :instance_id, :api_family, :api_version, :logger, :api_base
+    attr_writer :user_agent
+
+    def initialize(options = {})
+      # Defaults
+      @api_family = 'v1'
+      @api_version = '1.0.0'
+      @api_base = 'https://openapi.wix.com'
+
+      options.each do |key, value|
+        send(:"#{key}=", value)
+      end
+      yield(self) if block_given?
+
+      validate_configuration!
+    end
+
+    def headers=(options = {})
+      connection_options[:headers].merge!(options)
+    end
+
+    # :nocov:
+    def request_config=(options = {})
+      connection_options[:request].merge!(options)
+    end
+    # :nocov:
+
+    # @return [String]
+    def user_agent
+      @user_agent ||= "Hive Ruby Gem #{Hive::Version}"
+    end
+
+    def wix_request(request)
+      request(request.verb, request.path, request.options)
+    end
+
+    def request(method, path, options = {})
+      connection.send(method.to_sym) do |request|
+        request.url path, options.fetch(:params, {})
+        request.headers.update(options.fetch(:headers, {}))
+        body = options.fetch(:body, {})
+        request.body = body if  body.length > 0
+      end
+    rescue Faraday::Error::TimeoutError, Timeout::Error => error
+      raise(Hive::Response::Error::RequestTimeout, error)
+    rescue Faraday::Error::ClientError, JSON::ParserError => error
+      raise(Hive::Response::Error, error)
+    end
+
+    class << self
+      def parse_instance_data(signed_instance, app_secret)
+        signature, encoded_json = signed_instance.split('.', 2)
+
+        fail Hive::SignatureError, 'invalid signed instance' if signature.nil? || encoded_json.nil?
+
+        encoded_json_hack = encoded_json + ('=' * (4 - encoded_json.length.modulo(4)))
+
+        json_str = Base64.urlsafe_decode64(encoded_json_hack)
+
+        hmac = OpenSSL::HMAC.digest(OpenSSL::Digest::SHA256.new, app_secret, encoded_json)
+
+        my_signature = Base64.urlsafe_encode64(hmac).gsub('=', '')
+
+        fail Hive::SignatureError, 'the signatures do not match' if signature != my_signature
+
+        Hashie::Mash.new(JSON.parse(json_str))
+      end
+    end
+
+    private
+
+    def validate_configuration!
+      if secret_key.nil?
+        fail Hive::ConfigurationError, "Invalid secret key: #{secret_key}"
+      elsif app_id.nil?
+        fail Hive::ConfigurationError, "Invalid app id: #{app_id}"
+      elsif instance_id.nil?
+        fail Hive::ConfigurationError, "Invalid instance id: #{instance_id}"
+      end
+    end
+
+    def middleware
+      @middleware ||= Faraday::RackBuilder.new do |faraday|
+        # Checks for files in the payload, otherwise leaves everything untouched
+        faraday.request :multipart
+        # Encodes as "application/json" if not already encoded
+        faraday.request :json
+        # Encodes as "application/x-www-form-urlencoded" if not already encoded
+        faraday.request :url_encoded
+        # Handle error responses
+        faraday.response :raise_error
+        # Parse JSON response bodies
+        faraday.response :parse_json
+        # Log requests to the STDOUT
+        add_logger(faraday)
+        # Set default HTTP adapter
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+
+    # :nocov:
+    def add_logger(faraday)
+      case @logger
+      when :file
+        faraday.use Faraday::Response::Logger, Logger.new('hive.log')
+      when :stdout
+        faraday.use Faraday::Response::Logger
+      end
+    end
+    # :nocov:
+
+    # rubocop:disable Style/MethodLength:
+    def connection_options
+      @connection_options ||= {
+        builder: middleware,
+        headers: {
+          accept: 'application/json',
+          user_agent: user_agent
+        },
+        request: {
+          open_timeout: 10,
+          timeout: 30
+        }
+      }
+    end
+
+    def connection
+      @connection ||= Faraday.new(@api_base, connection_options)
+    end
+  end
+end

data/lib/hive/contact.rb

@@ -0,0 +1,153 @@
+require 'hashie'
+
+module Hive
+  class Name < Hashie::Trash
+    include Hashie::Extensions::IgnoreUndeclared
+    property :prefix
+    property :first
+    property :middle
+    property :last
+    property :suffix
+  end
+
+  class Company < Hashie::Trash
+    include Hashie::Extensions::IgnoreUndeclared
+    property :role
+    property :name
+  end
+
+  class Email < Hashie::Trash
+    include Hashie::Extensions::IgnoreUndeclared
+    property :id
+    property :tag
+    property :email
+    property :emailStatus
+    property :unsubscribeLink
+  end
+
+  class Phone < Hashie::Trash
+    include Hashie::Extensions::IgnoreUndeclared
+    property :id
+    property :tag
+    property :phone
+    property :normalizedPhone
+  end
+
+  class Address < Hashie::Trash
+    include Hashie::Extensions::IgnoreUndeclared
+    property :id
+    property :tag
+    property :address
+    property :neighborhood
+    property :city
+    property :region
+    property :country
+    property :postalCode
+  end
+
+  class Url < Hashie::Trash
+    include Hashie::Extensions::IgnoreUndeclared
+    property :id
+    property :tag
+    property :url
+  end
+
+  class Date < Hashie::Trash
+    include Hashie::Extensions::IgnoreUndeclared
+    property :id
+    property :tag
+    property :date, with: lambda { |v| Time.parse(v) }
+  end
+
+  class Note < Hashie::Trash
+    include Hashie::Extensions::IgnoreUndeclared
+    property :id
+    property :modifiedAt
+    property :content
+  end
+
+  class Custom < Hashie::Trash
+    include Hashie::Extensions::IgnoreUndeclared
+    property :id
+    property :field
+    property :value
+  end
+
+  class Link < Hashie::Trash
+    include Hashie::Extensions::IgnoreUndeclared
+    property :href
+    property :rel
+  end
+
+  class Contact < Hashie::Trash
+    include Hashie::Extensions::IgnoreUndeclared
+    include Hashie::Extensions::Coercion
+
+    coerce_key :name, Name
+    coerce_key :company, Company
+    coerce_key :emails, Array[Email]
+    coerce_key :phones, Array[Phone]
+    coerce_key :addresses, Array[Address]
+    coerce_key :urls, Array[Url]
+    coerce_key :dates, Array[Date]
+    coerce_key :notes, Array[Note]
+    coerce_key :custom, Array[Custom]
+    coerce_key :links, Array[Link]
+    property :id
+    property :name, default: Hive::Name.new
+    property :picture
+    property :company, default: Hive::Company.new
+    property :emails, default: []
+    property :phones, default: []
+    property :addresses, default: []
+    property :urls, default: []
+    property :dates, default: []
+    property :notes, default: []
+    property :custom, default: []
+    property :createdAt
+    property :links
+    property :modifiedAt
+
+    remove_method :emails=, :phones=, :addresses=, :urls=, :dates=, :notes=, :custom=, :links=
+
+    def add_email(args)
+      emails << Email.new(args)
+    end
+
+    def add_phone(args)
+      phones << Phone.new(args)
+    end
+
+    def add_address(args)
+      addresses << Address.new(args)
+    end
+
+    def add_url(args)
+      urls << Url.new(args)
+    end
+
+    def add_date(args)
+      dates << Date.new(args)
+    end
+
+    def add_note(args)
+      notes << Note.new(args)
+    end
+
+    def add_custom(args)
+      custom << Custom.new(args)
+    end
+  end
+
+  class ContactSubscriber < Hashie::Trash
+    include Hashie::Extensions::IgnoreUndeclared
+    include Hashie::Extensions::Coercion
+
+    coerce_key :name, Name
+    coerce_key :emails, Array[Email]
+
+    property :id
+    property :name, default: Hive::Name.new
+    property :emails, default: []
+  end
+end

data/lib/hive/cursor.rb

@@ -0,0 +1,48 @@
+require 'hashie'
+require 'hive/contact'
+require 'hive/activity'
+require 'hive/errors'
+
+module Hive
+  class Cursor <  Hashie::Trash
+    include Hashie::Extensions::IgnoreUndeclared
+
+    def initialize(hash, klass, current_request)
+      @next_request = current_request.clone
+      @klass = klass
+      super(hash)
+      self.results = results.map { |item| klass.new(item) }
+    end
+
+    property :total
+    property :pageSize
+    property :previousCursor
+    property :nextCursor
+    property :results, default: []
+
+    def next?
+      !nextCursor.nil? && nextCursor != '0'
+    end
+
+    def previous?
+      !previousCursor.nil? && previousCursor != '0'
+    end
+
+    def next_page
+      fail Hive::CursorOperationError, 'Next page not available!' if nextCursor.nil?
+      cursored_request(nextCursor)
+    end
+
+    def previous_page
+      fail Hive::CursorOperationError, 'Previous page not available!' if previousCursor.nil?
+      cursored_request(previousCursor)
+    end
+
+    private
+
+    def cursored_request(cursor)
+      @next_request.params.merge!(cursor: cursor)
+      @next_request.perform_with_cursor(@klass)
+    end
+  end
+end

data/lib/hive/errors.rb

@@ -0,0 +1,5 @@
+module Hive
+  class CursorOperationError < StandardError; end
+  class ConfigurationError < StandardError; end
+  class SignatureError < StandardError; end
+end

data/lib/hive/extensions/hashie_hash.rb

@@ -0,0 +1,16 @@
+module Hashie
+  class Hash < ::Hash
+    def flexibly_convert_to_hash(object, options = {})
+      if object.method(:to_hash).arity == 0
+        object.to_hash
+      else
+        object.to_hash(options)
+      end
+    rescue ArgumentError
+      # HACK: If the provided object overrides the method() definition (see Hive::Activities::Messaging::Recipient)
+      # we don't want the whole conversion to fail. So we assume execute the more likely to be present to_hash method.
+      # I have opened an issue here: https://github.com/intridea/hashie/issues/222
+      object.to_hash
+    end
+  end
+end

data/lib/hive/extensions/hashie_validate_enum.rb

@@ -0,0 +1,11 @@
+module Hashie
+  module Validate
+    module_function
+    def enum(enum)
+      lambda do |v|
+        fail ArgumentError, "Invalid value #{v} ! Valid ones are: #{enum}" unless enum.include?(v)
+        v
+      end
+    end
+  end
+end

data/lib/hive/rest/activities.rb

@@ -0,0 +1,55 @@
+require 'hive/activity'
+
+module Hive
+  module REST
+    module Activities
+      include Hive::Util
+
+      def add_contact_activity(id, activity)
+        read_only?(activity.activityType)
+
+        perform_with_object(:post,
+                            "v1/contacts/#{id}/activities",
+                            Hive::ActivityResult,
+                            body: activity.to_json)
+      end
+
+      def new_activity(session_token, activity)
+        read_only?(activity.activityType)
+
+        perform_with_object(:post,
+                            'v1/activities',
+                            Hive::ActivityResult,
+                            body: activity.to_json,
+                            params: { userSessionToken: session_token })
+      end
+
+      def activity(id)
+        perform_with_object(:get, "v1/activities/#{id}", Hive::Activity)
+      end
+
+      def contact_activities(id, query_options = {})
+        activities(query_options, "v1/contacts/#{id}/activities")
+      end
+
+      def activities(query_options = {}, path = 'v1/activities')
+        transform_activities_query(query_options)
+        perform_with_cursor(:get, path, Hive::Activity, params: query_options)
+      end
+
+      private
+
+      READ_ONLY_ACTIVITIES = [Hive::Activities::CONTACTS_CREATE.type]
+
+      def read_only?(activity_type)
+        fail ArgumentError,
+             "Activity is read only! Please provide an activity other than: #{READ_ONLY_ACTIVITIES}" if READ_ONLY_ACTIVITIES.find { |type| type == activity_type }
+      end
+
+      def transform_activities_query(query)
+        activity_types = query[:activityTypes]
+        query[:activityTypes] = activity_types.join(',') if activity_types && activity_types.respond_to?(:join)
+      end
+    end
+  end
+end