supplejack_client 1.0.1

data/lib/supplejack/controllers/helpers.rb

@@ -0,0 +1,172 @@
+# The Supplejack Client code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# See https://github.com/DigitalNZ/supplejack_client for details.
+#
+# Supplejack was created by DigitalNZ at the National Library of NZ
+# and the Department of Internal Affairs. http://digitalnz.org/supplejack
+
+require 'rails_autolink'
+
+module Supplejack
+  module Controllers
+    module Helpers
+      extend ActiveSupport::Concern
+
+      def search(special_params=nil)
+        return @supplejack_search if @supplejack_search
+        klass = Supplejack.search_klass ? Supplejack.search_klass.classify.constantize : Supplejack::Search
+        @supplejack_search = klass.new(special_params || params[:search] || params)
+      end
+
+      # Displays a record attribute with a label and allows you to customize the
+      # HTML markup generated. It will not display anything if the value is blank or nil.
+      #
+      # @param [ Record ] record Class which includes the Supplejack::Record module
+      # @param [ Symbol ] attribute The name of the attribute to return
+      # @param [ Hash ] options Hash of options to customize the output,
+      #   supported options: :label, :limit, :delimiter, :link_path, :tag
+      #
+      # @option options [ true, false ] :label Display the attribute name
+      # @option options [ String ] :label_tag HTML tag to surround label
+      # @option options [ String ] :label_class CSS class to apply to label_tag
+      # @option options [ Integer ] :limit Number of charachters to truncate or number of values (when multivalue field)
+      # @option options [ Integer ] :delimiter Used to separate multi value attributes
+      # @option options [ String ] :link_path The method name of a routes path when provided it will generate links for every value
+      # @option options [ Symbol ] :tag HTML tag to wrap the label and value
+      # @option options [ true, false, String ] :link When true will try to make the value into a link, When is a string it will try
+      #                                               to find a {{value}} within the string and replace it with the value.
+      # @option options [ String ] :extra_html HTML which will be included inside the tag at the end.
+      # @option options [ Symbol ] :tag_class The class for the attribute tag
+      #
+      # @return [ String ] A HTML snippet with the attribute name and value
+      #
+      def attribute(record, attributes, options={})
+        options.reverse_merge!(:label => true, :label_inline => true, :limit => nil, :delimiter => ", ",
+                                :link_path => false, :tag => Supplejack.attribute_tag, :label_tag => Supplejack.label_tag,
+                                :label_class => Supplejack.label_class, :trans_key => nil, :link => false,
+                                :extra_html => nil, :tag_class => nil)
+
+        value = []
+        attributes = [attributes] unless attributes.is_a?(Array)
+        attributes.each do |attribute|
+          if attribute.is_a?(String) && attribute.match(/\./)
+            object, attr = attribute.split(".")
+            v = record.try(object.to_sym).try(attr.to_sym) if object && attr
+          else
+            v = record.send(attribute)
+          end
+
+          if v.is_a?(Array)
+            value += v.compact
+          else
+            value << v if v.present?
+          end
+        end
+
+        value = value.first if value.size == 1
+        attribute = attributes.first
+
+        if value.is_a?(Array)
+          if options[:limit] && options[:limit].to_i > 0
+            value = value[0..(options[:limit].to_i-1)]
+          end
+
+          if options[:link_path]
+            value = value.map {|v| link_to(v, send(options[:link_path], {:i => {attribute => v}})) }
+          end
+
+          if options[:link]
+            value = value.map do |v|
+              attribute_link_replacement(v, options[:link])
+            end
+          end
+
+          value = value.join(options[:delimiter]).html_safe
+          value = truncate(value, :length => options[:limit]) if options[:limit].to_i > 20
+          value
+        else
+          if options[:limit] && options[:limit].to_i > 0
+            value = truncate(value, :length => options[:limit].to_i)
+          end
+
+          if options[:link]
+            value = attribute_link_replacement(value, options[:link])
+          end
+        end
+
+        content = ""
+        if options[:label]
+          if options[:trans_key].present?
+            translation = I18n.t(options[:trans_key], :default => attribute.to_s.capitalize) + ": "
+          else
+            i18n_class_name = record.class.to_s.tableize.downcase.gsub(/\//, "_")
+            translation = "#{I18n.t("#{i18n_class_name}.#{attribute}", :default => attribute.to_s.capitalize)}: "
+          end
+          content = content_tag(options[:label_tag], translation, :class => options[:label_class]).html_safe
+          content << "<br/>".html_safe unless options[:label_inline]
+        end
+
+        content << value.to_s
+        content << options[:extra_html] if options[:extra_html]
+        if value.present? and value != "Not specified"
+          options[:tag] ? content_tag(options[:tag], content.html_safe, :class => options[:tag_class]) : content.html_safe
+        end
+      end
+
+      # Displays the next and/or previous links based on the record and current search
+      #
+      # @params [ Dnz::Record ] The record object which has information about the next/previous record and pages.
+      # @params [ Hash ] options Hash of options to customize the output,
+      #   supported options: :prev_class, :next_class, :prev_label, :next_label
+      #
+      # @option options [ String ] :prev_class The CSS class to use on the previous button
+      # @option options [ String ] :next_class The CSS class to use on the next button
+      # @option options [ String ] :wrapper_class The CSS class to use on the wrapping span
+      # @option options [ String ] :prev_label Any HTML to be put inside the previous button
+      # @option options [ String ] :next_label Any HTML to be put inside the next button
+      #
+      def next_previous_links(record, html_options={})
+        html_options.reverse_merge!({prev_class: "prev", next_class: "next", wrapper_class: 'nav', prev_label: nil, next_label: nil})
+
+        return "" unless params[:search]
+        links = "".html_safe
+
+        options = search.options
+
+        previous_label = html_options[:prev_label] ||= t('supplejack_client.previous', default: "Previous")
+        next_label = html_options[:next_label] ||= t('supplejack_client.next', default: "Next")
+        previous_label = previous_label.html_safe
+        next_label = next_label.html_safe
+
+        options[:path] = params[:search][:path].gsub(/(\W|\d)/, '') if params[:search] && params[:search][:path]
+
+        if record.previous_record
+          options[:page] = record.previous_page if record.previous_page.to_i > 1
+          links += link_to(raw(previous_label), record_path(record.previous_record, search: options), class: html_options[:prev_class]).html_safe
+        else
+          links += content_tag(:span, previous_label, class: html_options[:prev_class])
+        end
+
+        if record.next_record
+          options[:page] = record.next_page if record.next_page.to_i > 1
+          links += link_to(raw(next_label), record_path(record.next_record, search: options), class: html_options[:next_class]).html_safe
+        else
+          links += content_tag(:span, next_label, class: html_options[:next_class])
+        end
+
+        content_tag(:span, links, class: html_options[:wrapper_class])
+      end
+
+      def attribute_link_replacement(value, link_pattern)
+        if link_pattern.is_a?(String)
+          link_pattern = URI.decode(link_pattern)
+          url = link_pattern.gsub("{{value}}", value)
+          link_to(value, url)
+        else
+          auto_link value
+        end
+      end
+
+    end
+  end
+end

data/lib/supplejack/engine.rb

@@ -0,0 +1,20 @@
+# The Supplejack Client code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# See https://github.com/DigitalNZ/supplejack_client for details.
+#
+# Supplejack was created by DigitalNZ at the National Library of NZ
+# and the Department of Internal Affairs. http://digitalnz.org/supplejack
+
+require 'supplejack_client'
+require 'rails'
+
+module Supplejack
+  class Engine < Rails::Engine
+
+    initializer "supplejack.helpers" do
+      ActionView::Base.send :include, Supplejack::Controllers::Helpers
+      ActionController::Base.send :include, Supplejack::Controllers::Helpers
+    end
+
+  end
+end

data/lib/supplejack/exceptions.rb

@@ -0,0 +1,17 @@
+# The Supplejack Client code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# See https://github.com/DigitalNZ/supplejack_client for details.
+#
+# Supplejack was created by DigitalNZ at the National Library of NZ
+# and the Department of Internal Affairs. http://digitalnz.org/supplejack
+
+module Supplejack
+  class RecordNotFound < StandardError
+  end
+
+  class SetNotFound < StandardError
+  end
+
+  class MalformedRequest < StandardError
+  end
+end

data/lib/supplejack/facet.rb

@@ -0,0 +1,33 @@
+# The Supplejack Client code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# See https://github.com/DigitalNZ/supplejack_client for details.
+#
+# Supplejack was created by DigitalNZ at the National Library of NZ
+# and the Department of Internal Affairs. http://digitalnz.org/supplejack
+
+module Supplejack
+  class Facet
+    
+    attr_reader :name
+    
+    def initialize(name, values)
+      @name = name
+      @values = values
+    end
+
+    def values(sort=nil)
+      sort = sort || Supplejack.facets_sort
+
+      array = case sort.try(:to_sym)
+              when :index
+                @values.sort_by {|k,v| k.to_s }
+              when :count
+                @values.sort_by {|k,v| -v.to_i }
+              else
+                @values.to_a
+              end
+
+      ActiveSupport::OrderedHash[array]
+    end
+  end
+end

data/lib/supplejack/item.rb

@@ -0,0 +1,94 @@
+# The Supplejack Client code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# See https://github.com/DigitalNZ/supplejack_client for details.
+#
+# Supplejack was created by DigitalNZ at the National Library of NZ
+# and the Department of Internal Affairs. http://digitalnz.org/supplejack
+
+module Supplejack
+
+  # The +Item+ class represents a SetItem on the Supplejack API
+  #
+  # An Item always belongs to a UserSet. In the API the SetItem class
+  # only has a record_id and position, but it gets augmented with some 
+  # of the attributes of the Record that it represents.
+  #
+  # An Item object can have the following values:
+  # - record_id
+  # - position
+  # 
+  # If more attributes of the Record are needed, they should be added to the SetItem::ATTRIBUTES
+  # array in the API SetItem model.
+  # 
+  class Item
+    include Supplejack::Request
+    
+    ATTRIBUTES = [:record_id, :date]
+
+    attr_reader *ATTRIBUTES
+    attr_reader :attributes, :user_set_id
+    attr_accessor :api_key, :errors, :position
+
+    def initialize(attributes={})
+      @attributes = attributes.try(:symbolize_keys) || {}
+      @user_set_id = @attributes[:user_set_id]
+      @api_key = @attributes[:api_key]
+      @position = @attributes[:position]
+
+      ATTRIBUTES.each do |attribute|
+        self.instance_variable_set("@#{attribute}", @attributes[attribute])
+      end
+    end
+
+    def attributes
+      Hash[ATTRIBUTES.map {|attr| [attr, self.send(attr)]}]
+    end
+
+    def id
+      self.record_id
+    end
+
+    # Executes a POST request to the API to persist the current Item
+    #
+    # @return [ true, false ] True if the API response was successful, false if not.
+    #
+    def save
+      begin
+        api_attributes = {record_id: self.record_id}
+        api_attributes[:position] = self.position if self.position.present?
+        post("/sets/#{self.user_set_id}/records", {api_key: self.api_key}, {record: api_attributes})
+        Rails.cache.delete("/users/#{self.api_key}/sets") if Supplejack.enable_caching
+        return true
+      rescue StandardError => e
+        self.errors = e.inspect
+        return false
+      end
+    end
+
+    # Executes a DELETE request to the API to remove the current Item
+    #
+    # @return [ true, false ] True if the API response was successful, false if not.
+    #
+    def destroy
+      begin
+        delete("/sets/#{self.user_set_id}/records/#{self.record_id}", {api_key: self.api_key})
+        Rails.cache.delete("/users/#{self.api_key}/sets") if Supplejack.enable_caching
+        return true
+      rescue StandardError => e
+        self.errors = e.inspect
+        return false
+      end
+    end
+
+    # Date getter to force the date attribute to be a Date object.
+    #
+    def date
+      @date = @date.first if @date.is_a?(Array)
+      Time.parse(@date) rescue nil if @date
+    end
+
+    def method_missing(symbol, *args, &block)
+      return nil
+    end
+  end
+end

data/lib/supplejack/item_relation.rb

@@ -0,0 +1,73 @@
+# The Supplejack Client code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# See https://github.com/DigitalNZ/supplejack_client for details.
+#
+# Supplejack was created by DigitalNZ at the National Library of NZ
+# and the Department of Internal Affairs. http://digitalnz.org/supplejack
+
+module Supplejack
+
+  # The +ItemRelation+ class provides ActiveRecord like functionality to the
+  # relationship between a UserSet object and it's Item objects.
+  # 
+  # @exmaple 
+  #   user_set = user.sets.first
+  #
+  #   user_set.items.build({record_id: 1})              => Returns a new Item object linked to the UserSet
+  #   user_set.items.find(1)                            => Return a Item object which belongs to the UserSet
+  #
+  class ItemRelation
+    include Supplejack::Request
+
+    attr_reader :user_set, :items
+
+    def initialize(user_set)
+      @user_set = user_set
+      items_array = user_set.attributes[:records] || []
+      @items = items_array.map { |hash| Supplejack::Item.new(hash.merge(user_set_id: user_set.id, api_key: user_set.api_key)) }
+    end
+
+    # Returns an Array with all items for the current UserSet
+    #
+    def all
+      @items
+    end
+
+    # Finds the item based on the record_id and returns it.
+    #
+    def find(record_id)
+      @items.detect {|i| i.record_id == record_id.to_i}
+    end
+
+    # Initializes a new Item with the provided attributes
+    #
+    # @return [ Supplejack::Item ] A new Supplejack::Item object
+    # 
+    def build(attributes={})
+      attributes ||= {}
+      attributes[:user_set_id] = self.user_set.id
+      attributes[:api_key] = self.user_set.api_key
+      Supplejack::Item.new(attributes)
+    end
+
+    # Initializes and persists the Item to the API
+    #
+    # @return [ true, false ] True if the API response was successful, false if not.
+    #
+    def create(attributes={})
+      item = self.build(attributes)
+      item.save
+    end
+
+    # Any method missing on this class is delegated to the Item objects array
+    # so that the developer can easily execute any Array method on the ItemRelation
+    #
+    # @example
+    #   user_set.items.each ....     => Iterate through the Item objects array
+    #   user_set.items.size          => Get the size of the Item objects array
+    # 
+    def method_missing(method, *args, &block)
+      @items.send(method, *args, &block)
+    end
+  end
+end

data/lib/supplejack/log_subscriber.rb

@@ -0,0 +1,58 @@
+# The Supplejack Client code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# See https://github.com/DigitalNZ/supplejack_client for details.
+#
+# Supplejack was created by DigitalNZ at the National Library of NZ
+# and the Department of Internal Affairs. http://digitalnz.org/supplejack
+
+module Supplejack
+  class LogSubscriber < ActiveSupport::LogSubscriber
+
+    def log_request(duration, payload, solr_request_params={})
+      return unless Supplejack.enable_debugging
+      
+      solr_request_params ||= {}
+      payload ||= {}
+      payload.reverse_merge!({:params => {}, :options => {}, :payload => {}})
+      method = payload[:method] || :get
+      
+      name = '%s (%.1fms)' % ["Supplejack API #{api_environment}", duration]
+
+      parameters = payload[:params].map { |k, v| "#{k}: #{colorize(v, BOLD)}" }.join(', ')
+      body = payload[:payload].map { |k, v| "#{k}: #{colorize(v, BOLD)}" }.join(', ')
+      options = payload[:options].map { |k, v| "#{k}: #{colorize(v, BOLD)}" }.join(', ')
+      request = "#{method.to_s.upcase} path=#{payload[:path]} params={#{parameters}}, body={#{body}} options={#{options}}"
+
+      if payload[:exception]
+        info = "\n  #{colorize('Exception', RED)} [ #{payload[:exception].join(', ')} ]"
+      else
+        info = ""
+        if solr_request_params.try(:any?)
+          solr_request_params = solr_request_params.map { |k, v| "#{k}: #{colorize(v, BOLD)}" }.join(', ')
+          info = "\n  #{colorize('SOLR Request', YELLOW)} [ #{solr_request_params} ]"
+        end
+      end
+
+      debug "  #{colorize(name, GREEN)}  [ #{request} ] #{info}"
+    end
+    
+    def colorize(text, color)
+      if text.is_a?(Hash)
+        "{#{text.map {|k, v| "#{k}: #{colorize(v, color)}" }.join(', ')}}"
+      elsif text.is_a?(Array)
+        "[#{text.map {|e| colorize(e, color) }.join(', ')}]"
+      else
+        "#{BOLD}#{color}#{text}#{CLEAR}"
+      end
+    end
+    
+    def api_environment
+      case Supplejack.api_url
+      when "http://api.digitalnz.org" then "Prod"
+      when /(hippo.uat)|(api.uat)/ then "Staging"
+      else
+        "Dev"
+      end
+    end
+  end
+end