traitify 1.1.0

data/lib/traitify/client/results.rb

@@ -0,0 +1,17 @@
+module Traitify
+  class Client
+    module Result
+      def find_results(assessment_id, image_pack = nil)
+        image_pack ||= self.image_pack
+
+        if image_pack
+          response = get("/assessments/#{assessment_id}/personality_types?image_pack=#{image_pack}")
+        else
+          response = get("/assessments/#{assessment_id}/personality_types")
+        end
+
+        Traitify::Result.parse_json(response)
+      end
+    end
+  end
+end

data/lib/traitify/client/slides.rb

@@ -0,0 +1,36 @@
+module Traitify
+  class Client
+    module Slide
+      def find_slides(assessment_id)
+        response = get("/assessments/#{assessment_id}/slides")
+
+        Traitify::Slides.parse_json(assessment_id, response)
+      end
+
+      def update_slides(slides)
+        response = put("/assessments/#{slides.assessment_id}/slides", slides.to_update_params)
+
+        Traitify::Slides.parse_json(slides.assessment_id, response)
+      end
+
+      def update_slide(hash_or_assessment_id, slide = nil)
+        if slide
+          assessment_id = hash_or_assessment_id
+          slide_id = slide.id
+          hash = slide.to_update_params.tap { |s| s.delete(:id) }
+        else
+          assessment_id = hash_or_assessment_id[:assessment_id]
+          slide_id =      hash_or_assessment_id[:slide_id]
+          hash = {
+            response:   hash_or_assessment_id[:response],
+            time_taken: hash_or_assessment_id[:time_taken]
+          }
+        end
+
+        response = put("/assessments/#{assessment_id}/slides/#{slide_id}", hash)
+
+        Traitify::Slide.parse_json(response)
+      end
+    end
+  end
+end

data/lib/traitify/client/users.rb

@@ -0,0 +1,17 @@
+module Traitify
+  class Client
+    module User
+      def create_user(user_params)
+        response = post("/users", user: user_params)
+
+        Traitify::User.parse_json(response)
+      end
+
+      def find_user(user_id)
+        response = get("/users/#{user_id}")
+
+        Traitify::User.parse_json(response)
+      end
+    end
+  end
+end

data/lib/traitify/configuration.rb

@@ -0,0 +1,21 @@
+module Traitify
+  module Configuration
+    VALID_OPTIONS_KEYS = [
+      :secret,
+      :api_host,
+      :api_version,
+      :deck_id,
+      :image_pack
+    ]
+
+    attr_accessor(*VALID_OPTIONS_KEYS)
+
+    def configure
+      yield self
+    end
+
+    def options
+      VALID_OPTIONS_KEYS.inject({}){|o,k| o.merge!(k => send(k)) }
+    end
+  end
+end

data/lib/traitify/connection.rb

@@ -0,0 +1,46 @@
+require "faraday_middleware"
+require "traitify/error"
+
+module Traitify
+  module Connection
+    def connection(options = {})
+      connection ||= Faraday.new(options) do |faraday|
+        faraday.request :url_encoded
+        faraday.request :basic_auth, self.secret, "x"
+        faraday.use ContentTypeMiddleware
+        faraday.use ErrorMiddleware
+        faraday.response :json, :content_type => /\bjson$/
+        faraday.adapter Faraday.default_adapter
+      end
+
+      connection
+    end
+
+    private
+    class ContentTypeMiddleware < Faraday::Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        env[:request_headers]["Accept"] = "application/json"
+        env[:request_headers]["Content-Type"] = "application/json"
+        @app.call(env)
+      end
+    end
+
+    class ErrorMiddleware < Faraday::Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env).on_complete do |e|
+          if error = Traitify::Error.from(e[:response])
+            raise error
+          end
+        end
+      end
+    end
+  end
+end

data/lib/traitify/error.rb

@@ -0,0 +1,44 @@
+module Traitify
+  class Error < StandardError
+    attr_accessor :response
+
+    def self.from(response)
+      status  = response.status
+
+      if klass = case status
+                 when 400 then Traitify::BadRequest
+                 when 401 then Traitify::Unauthorized
+                 when 404 then Traitify::NotFound
+                 when 422 then Traitify::UnprocessableEntity
+                 end
+
+        klass.new(response)
+      end
+    end
+
+    def initialize(response)
+      @response = response
+      super(error_message)
+    end
+
+    def errors
+      response.body
+    end
+
+    private
+    def error_message
+      message =  "#{response.env[:method].upcase} "
+      message << "#{response.env[:url].to_s} | "
+      message << "#{response.status}: "
+      if response.body && response.body.respond_to?(map)
+        message << "#{response.body.map{|k,v| "#{k}: #{v.first}"}.join(", ")}"
+      end
+      message
+    end
+  end
+
+  class BadRequest < Error; end
+  class Unauthorized < Error; end
+  class NotFound < Error; end
+  class UnprocessableEntity < Error; end
+end

data/lib/traitify/personality_blends.rb

@@ -0,0 +1,55 @@
+module Traitify
+  class PersonalityBlend
+    attr_accessor :personality_type_1, :personality_type_2, :name, :description, :compliments, :conflicts, :compatible_work_environment_1, :compatible_work_environment_2, :compatible_work_environment_3, :compatible_work_environment_4
+
+    def initialize(options = {})
+      self.personality_type_1             = options[:personality_type_1]
+      self.personality_type_2             = options[:personality_type_2]
+      self.name                           = options[:name]
+      self.description                    = options[:description]
+      self.compliments                    = options[:compliments]
+      self.conflicts                      = options[:conflicts]
+      self.compatible_work_environment_1 = options[:compatible_work_environment_1]
+      self.compatible_work_environment_2 = options[:compatible_work_environment_2]
+      self.compatible_work_environment_3 = options[:compatible_work_environment_3]
+      self.compatible_work_environment_4 = options[:compatible_work_environment_4]
+    end
+
+    def self.parse_json(personality_blend)
+      if personality_blend
+        personality_type_1 = PersonalityType.parse_json(personality_blend["personality_type_1"])
+        personality_type_2 = PersonalityType.parse_json(personality_blend["personality_type_2"])
+
+      PersonalityBlend.new(
+        personality_type_1:            personality_type_1,
+        personality_type_2:            personality_type_2,
+        name:                          personality_blend["name"],
+        description:                   personality_blend["description"],
+        compliments:                   personality_blend["compliments"],
+        conflicts:                     personality_blend["conflicts"],
+        compatible_work_environment_1: personality_blend["compatible_work_environment_1"],
+        compatible_work_environment_2: personality_blend["compatible_work_environment_2"],
+        compatible_work_environment_3: personality_blend["compatible_work_environment_3"],
+        compatible_work_environment_4: personality_blend["compatible_work_environment_4"]
+      )
+      else
+        nil
+      end
+    end
+
+    def to_hash
+      {
+        personality_type_1:            personality_type_1.to_hash,
+        personality_type_2:            personality_type_2.to_hash,
+        name:                          name,
+        description:                   description,
+        compliments:                   compliments,
+        conflicts:                     conflicts,
+        compatible_work_environment_1: compatible_work_environment_1,
+        compatible_work_environment_2: compatible_work_environment_2,
+        compatible_work_environment_3: compatible_work_environment_3,
+        compatible_work_environment_4: compatible_work_environment_4
+      }
+    end
+  end
+end

data/lib/traitify/personality_types.rb

@@ -0,0 +1,39 @@
+module Traitify
+  class PersonalityType
+    attr_accessor :id, :name, :description, :badge, :score
+
+    def initialize(options = {})
+      self.id          = options[:id]
+      self.name        = options[:name]
+      self.description = options[:description]
+      self.badge       = options[:badge]
+      self.score       = options[:score]
+    end
+
+    def self.parse_json(personality_type)
+      if personality_type
+        badge = Badge.parse_json(personality_type["badge"])
+
+        PersonalityType.new(
+          id:          personality_type["id"],
+          name:        personality_type["name"],
+          description: personality_type["description"],
+          badge:       badge,
+          score:       personality_type["score"]
+        )
+      else
+        nil
+      end
+    end
+
+    def to_hash
+      {
+        id:          id,
+        name:        name,
+        description: description,
+        badge:       badge.to_hash,
+        score:       score
+      }
+    end
+  end
+end

data/lib/traitify/request.rb

@@ -0,0 +1,46 @@
+module Traitify
+  module Request
+    def get(path, options = {})
+      request(:get, path, options)
+    end
+
+    def post(path, options = {})
+      request(:post, path, options)
+    end
+
+    def put(path, options = {})
+      request(:put, path, options)
+    end
+
+    def delete(path, options = {})
+      request(:delete, path, options)
+    end
+
+    def last_response
+      @last_response
+    end
+
+    private
+    def request(method, path, options = {})
+      path = "#{self.api_version}#{path}"
+      connection_options = {}.merge!(url: self.api_host)
+
+      response = connection(connection_options).send(method) do |request|
+        request.body = options.to_json if options
+        case method
+        when :get
+          request.url(path)
+        when :post
+          request.url(path)
+        when :put
+          request.url(path)
+        when :delete
+          request.url(path)
+        end
+      end
+
+      @last_response = response
+      response.body
+    end
+  end
+end

data/lib/traitify/results.rb

@@ -0,0 +1,31 @@
+module Traitify
+  class Result
+    attr_accessor :personality_blend, :personality_types
+
+    def initialize(options = {})
+      self.personality_blend = options[:personality_blend]
+      self.personality_types = options[:personality_types]
+    end
+
+    def self.parse_json(result)
+      if result
+        personality_blend = PersonalityBlend.parse_json(result["personality_blend"])
+        personality_types = result["personality_types"].collect { |p| p && p["personality_type"] ? PersonalityType.parse_json(p["personality_type"].merge!("score" => p["score"])) : nil }
+
+        Result.new(
+          personality_blend: personality_blend,
+          personality_types: personality_types
+        )
+      else
+        nil
+      end
+    end
+
+    def to_hash
+      {
+        personality_blend: personality_blend.to_hash,
+        personality_types: personality_types.collect { |p| p.to_hash }
+      }
+    end
+  end
+end

data/lib/traitify/slides.rb

@@ -0,0 +1,95 @@
+module Traitify
+  class Slide
+    attr_accessor :id, :position, :caption, :image_desktop, :image_desktop_retina, :image_phone_landscape, :image_phone_portrait, :response, :time_taken, :completed_at, :created_at
+
+    def initialize(options = {})
+      self.id                    = options[:id]
+      self.position              = options[:position]
+      self.caption               = options[:caption]
+      self.image_desktop         = options[:image_desktop]
+      self.image_desktop_retina  = options[:image_desktop_retina]
+      self.image_phone_landscape = options[:image_phone_landscape]
+      self.image_phone_portrait  = options[:image_phone_portrait]
+      self.response              = options[:response]
+      self.time_taken            = options[:time_taken]
+      self.completed_at          = options[:completed_at]
+      self.created_at            = options[:created_at]
+    end
+
+    def self.parse_json(slide)
+      created_at = slide["created_at"] ? Time.at(slide["created_at"]) : nil
+      completed_at = slide["completed_at"] ? Time.at(slide["completed_at"]) : nil
+
+      Slide.new(
+        id:                    slide["id"],
+        position:              slide["position"],
+        caption:               slide["caption"],
+        image_desktop:         slide["image_desktop"],
+        image_desktop_retina:  slide["image_desktop_retina"],
+        image_phone_landscape: slide["image_phone_landscape"],
+        image_phone_portrait:  slide["image_phone_portrait"],
+        response:              slide["response"],
+        time_taken:            slide["time_taken"],
+        completed_at:          completed_at,
+        created_at:            created_at
+      )
+    end
+
+    def to_hash
+      {
+        id:                    id,
+        position:              position,
+        caption:               caption,
+        image_desktop:         image_desktop,
+        image_desktop_retina:  image_desktop_retina,
+        image_phone_landscape: image_phone_landscape,
+        image_phone_portrait:  image_phone_portrait,
+        response:              response,
+        time_taken:            time_taken,
+        completed_at:          completed_at,
+        created_at:            created_at
+      }
+    end
+
+    def to_update_params
+      {
+        id:                    id,
+        response:              response,
+        time_taken:            time_taken
+      }
+    end
+  end
+
+  class Slides
+    attr_accessor :assessment_id, :all
+
+    def initialize(options = {})
+      self.assessment_id = options[:assessment_id]
+      self.all           = options[:all]
+    end
+
+    def self.parse_json(assessment_id, slides)
+      Slides.new(
+        assessment_id: assessment_id,
+        all:           slides.collect { |slide| Traitify::Slide.parse_json(slide) }
+      )
+    end
+
+    def to_hash
+      {
+        assessment_id: assessment_id,
+        all:           all.collect { |slide| slide.to_hash }
+      }
+    end
+
+    def to_update_params
+      all.collect { |slide| slide.to_update_params }
+    end
+
+    # Allows slides to forward Array methods to all
+    def method_missing(method, *args)
+      return all.send(method, *args) if all.respond_to?(method)
+      super
+    end
+  end
+end