supplejack_api 1

data/app/models/supplejack_api/user_activity.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api for details.
+#
+# Supplejack was created by DigitalNZ at the National Library of NZ and
+# the Department of Internal Affairs. http://digitalnz.org/supplejack
+
+module SupplejackApi
+  class UserActivity
+    include Mongoid::Document
+    include Mongoid::Timestamps
+
+    store_in collection: 'user_activities'
+
+    belongs_to :user, class_name: 'SupplejackApi::User'
+
+    field :user_sets,       type: Hash
+    field :search,          type: Hash
+    field :records,         type: Hash
+    field :custom_searches, type: Hash
+    field :total,           type: Integer
+
+    index created_at: 1
+
+    def self.build_from_user(daily_activity)
+      user_activity = new
+      daily_activity ||= {}
+
+      %w(user_sets search records custom_searches).each do |group|
+        group_activity = daily_activity[group]
+
+        if group_activity
+          user_activity[group] = group_activity
+          user_activity.calculate_total_for(group)
+        end
+      end
+
+      user_activity.calculate_total
+      user_activity
+    end
+
+    def calculate_total_for(field)
+      total = 0
+
+      if activities = self[field]
+        activities.each { |_action, count| total += count.to_i }
+      else
+        activities = {}
+      end
+
+      activities['total'] = total
+      self[field] = activities
+    end
+
+    def calculate_total
+      count = 0
+      %w(user_sets search records custom_searches).each do |group|
+        values = send(group)
+        count += values['total'].to_i if values && values.is_a?(Hash)
+      end
+      self.total = count
+    end
+  end
+end

data/app/models/supplejack_api/user_set.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api for details.
+#
+# Supplejack was created by DigitalNZ at the National Library of NZ and
+# the Department of Internal Affairs. http://digitalnz.org/supplejack
+
+module SupplejackApi
+  class UserSet
+    include Mongoid::Document
+    include Mongoid::Timestamps
+    include ActionView::Helpers::SanitizeHelper
+    include ActiveModel::MassAssignmentSecurity
+    include SupplejackApi::Concerns::UserSet
+  end
+end

data/app/serializers/supplejack_api/application_serializer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api for details.
+#
+# Supplejack was created by DigitalNZ at the National Library of NZ and
+# the Department of Internal Affairs. http://digitalnz.org/supplejack
+
+module SupplejackApi
+  class ApplicationSerializer < ActiveModel::Serializer
+  end
+end

data/app/serializers/supplejack_api/concept_record_serializer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api for details.
+#
+# Supplejack was created by DigitalNZ at the National Library of NZ and
+# the Department of Internal Affairs. http://digitalnz.org/supplejack
+
+module SupplejackApi
+  class ConceptRecordSerializer < ActiveModel::Serializer
+    attributes :title, :description, :date, :display_content_partner, :display_collection, :thumbnail_url
+
+    TYPE_PROXY = 'edm:ProvidedCHO'
+
+    def serializable_hash
+      hash = {}
+      hash['@id'] = "http://#{ENV['WWW_DOMAIN']}/records/#{object.record_id}"
+      hash['@type'] = TYPE_PROXY
+      hash = hash.merge!(attributes)
+      hash
+    end
+  end
+end

data/app/serializers/supplejack_api/concept_search_serializer.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api for details.
+#
+# Supplejack was created by DigitalNZ at the National Library of NZ and
+# the Department of Internal Affairs. http://digitalnz.org/supplejack
+
+module SupplejackApi
+  class ConceptSearchSerializer < SearchSerializer
+  end
+end

data/app/serializers/supplejack_api/concept_serializer.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api for details.
+#
+# Supplejack was created by DigitalNZ at the National Library of NZ and
+# the Department of Internal Affairs. http://digitalnz.org/supplejack
+
+module SupplejackApi
+  class ConceptSerializer < ActiveModel::Serializer
+    has_many :source_authorities, serializer: SupplejackApi::SourceAuthoritySerializer
+    has_many :records, serializer: SupplejackApi::ConceptRecordSerializer
+
+    ConceptSchema.groups.keys.each do |group|
+      define_method("#{group}?") do
+        return false unless options[:groups].try(:any?)
+        options[:groups].include?(group)
+      end
+    end
+
+    def serializable_hash
+      hash = attributes
+      # Create empty context block to add to once we know what fields we have.
+      hash['@context'] = {}
+      hash['@type'] = object.concept_type
+      hash['@id'] = object.site_id
+
+      if default? || verbose?
+        groups = (options[:groups] & ConceptSchema.groups.keys) || []
+        fields = Set.new
+
+        groups.each do |group|
+          fields.merge(ConceptSchema.groups[group].try(:fields)) rescue {}
+        end
+
+        fields.each do |field|
+          # Doesn't allow the real record id to be overwritten by mongo id
+          hash[field] = field == :id ? hash[field] : field_value(field, options)
+        end
+      end
+
+      include_individual_fields!(hash)
+      include_context_fields!(hash)
+      include_reverse_fields!(hash) if reverse?
+      include!(:source_authorities, node: hash) if source_authorities?
+      hash
+    end
+
+    def include_context_fields!(hash)
+      fields = hash.dup
+      fields.keep_if { |field| ConceptSchema.model_fields.include?(field) }
+      field_keys = fields.keys
+
+      # Include unstored fields from the Schema
+      record_fields = ConceptSchema.model_fields.select { |_key, value| value.try(:store) == false }
+      field_keys += record_fields.keys
+
+      hash['@context'] = if options[:inline_context]
+                           Concept.build_context(field_keys)
+                         else
+                           object.context
+                         end
+      hash
+    end
+
+    def include_individual_fields!(hash)
+      if options[:fields].present?
+        options[:fields].push(:concept_id)
+        options[:fields].sort!
+        options[:fields].each do |field|
+          hash[field] = object.send(field)
+        end
+      end
+      hash
+    end
+
+    def include_reverse_fields!(hash)
+      hash['@reverse'] = {}
+      key = concept.edm_type
+      include!(:records, node: hash['@reverse'], key: key)
+      hash
+    end
+
+    def field_value(field)
+      value = if ConceptSchema.fields[field].try(:search_value) && ConceptSchema.fields[field].try(:store) == false
+                ConceptSchema.fields[field].search_value.call(object)
+              else
+                object.public_send(field)
+              end
+
+      value = ConceptSchema.fields[field].try(:default_value) if value.nil? rescue nil
+
+      if ConceptSchema.fields[field].try(:date_format)
+        value = format_date(value, ConceptSchema.fields[field].try(:date_format))
+      end
+
+      value
+    end
+  end
+end

data/app/serializers/supplejack_api/concerns/record_serializable.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+module SupplejackApi::Concerns::RecordSerializable
+  extend ActiveSupport::Concern
+
+  included do
+  end
+
+  RecordSchema.groups.keys.each do |group|
+    define_method("#{group}?") do
+      return false unless options[:groups].try(:any?)
+      options[:groups].include?(group)
+    end
+  end
+
+  def to_xml(*_args)
+    serializable_hash.to_xml(root: 'record')
+  end
+
+  def remove_restricted_fields!(hash)
+    role_field_restrictions.each do |conditional_field, restrictions|
+      restrictions.each do |condition, restricted_fields|
+        if field_restricted?(conditional_field, condition)
+          remove_field_values(restricted_fields, hash)
+        end
+      end
+    end
+  end
+
+  # REFACTOR -- Used in concept_serializer.rb too
+  def field_value(field, _options = {})
+    value = if RecordSchema.fields[field].try(:search_value) && RecordSchema.fields[field].try(:store) == false
+              RecordSchema.fields[field].search_value.call(object)
+            else
+              object.public_send(field)
+            end
+
+    value = RecordSchema.fields[field].try(:default_value) if value.nil? rescue nil
+
+    if RecordSchema.fields[field].try(:date_format)
+      value = format_date(value, RecordSchema.fields[field].try(:date_format))
+    end
+
+    value
+  end
+
+  def role
+    @role ||= options[:scope].role.to_sym rescue nil
+  end
+
+  def format_date(date, format)
+    date.strftime(format) rescue date
+  end
+
+  def role_field_restrictions
+    restrictions = []
+
+    if role && RecordSchema.roles[role] && RecordSchema.roles[role].field_restrictions.present?
+      restrictions = RecordSchema.roles[role].field_restrictions
+    end
+
+    restrictions
+  end
+
+  def field_restricted?(conditional_field, condition)
+    field_values = field_value(conditional_field).to_a
+    restricted = false
+
+    field_values.each do |value|
+      if (condition.is_a?(Regexp) && value.match(condition)) ||
+         (condition.is_a?(String) && value.include?(condition))
+        restricted = true
+      end
+      break if restricted
+    end
+
+    restricted
+  end
+
+  def remove_field_values(restricted_fields, hash)
+    restricted_fields.each do |field|
+      hash[field.to_sym] = nil
+    end
+  end
+
+  # Returns a hash including all desirable record attributes and its associations
+  def serializable_hash
+    hash = attributes
+    groups = (options[:groups] & RecordSchema.groups.keys) || []
+    fields = Set.new
+    groups.each do |group|
+      fields.merge(RecordSchema.groups[group].try(:fields))
+    end
+
+    # hash[:id] = field_value(:record_id, options) if fields.any?
+    fields.each do |field|
+      hash[field] = field_value(field, options)
+    end
+
+    include_individual_fields!(hash)
+    remove_restricted_fields!(hash)
+
+    hash[:next_page] = object.next_page if object.next_page.present?
+    hash[:next_record] = object.next_record if object.next_record.present?
+    hash[:previous_page] = object.previous_page if object.previous_page.present?
+    hash[:previous_record] = object.previous_record if object.previous_record.present?
+
+    hash
+  end
+
+  def include_individual_fields!(hash)
+    if options[:fields].present?
+      options[:fields].each do |field|
+        hash[field] = record.send(field)
+      end
+    end
+
+    hash
+  end
+end

data/app/serializers/supplejack_api/concerns/search_serializable.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module SupplejackApi::Concerns::SearchSerializable
+  extend ActiveSupport::Concern
+
+  included do
+    def serializable_hash
+      hash = {}
+      hash[:result_count] = object.total
+      hash[:results] = records_serialized_array
+      hash[:per_page] = object.per_page
+      hash[:page] = object.page
+      hash[:request_url] = object.request_url
+      hash[:solr_request_params] = object.solr_request_params if object.solr_request_params
+      hash[:warnings] = object.warnings if object.warnings.present?
+      hash[:suggestion] = object.collation if object.options[:suggest]
+      hash
+    end
+
+    def records_serialized_array
+      args = { fields: object.field_list, groups: object.group_list, scope: object.scope }
+      ActiveModel::ArraySerializer.new(object.results, args)
+    end
+  end
+end

data/app/serializers/supplejack_api/record_search_serializer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api for details.
+#
+# Supplejack was created by DigitalNZ at the National Library of NZ and
+# the Department of Internal Affairs. http://digitalnz.org/supplejack
+
+module SupplejackApi
+  class RecordSearchSerializer < SearchSerializer
+    RecordSchema.groups.keys.each do |group|
+      define_method("#{group}?") do
+        return false unless options[:groups].try(:any?)
+        options[:groups].include?(group)
+      end
+    end
+
+    def json_facets
+      facets = {}
+      object.facets.map do |facet|
+        rows = {}
+        facet.rows.each do |row|
+          rows[row.value] = row.count
+        end
+
+        facets.merge!(facet.name => rows)
+      end
+      facets
+    end
+
+    def xml_facets
+      facets = []
+      object.facets.map do |facet|
+        values = facet.rows.map do |row|
+          { name: row.value, count: row.count }
+        end
+        facets << { name: facet.name.to_s, values: values }
+      end
+      facets
+    end
+
+    def to_json(options = {})
+      rendered_json = as_json(options).to_json
+      rendered_json = "#{object.jsonp}(#{rendered_json})" if object.jsonp
+      rendered_json
+    end
+
+    def as_json(_options = {})
+      hash = { search: serializable_hash }
+      hash[:search][:facets] = json_facets
+      hash
+    end
+
+    def to_xml(*args)
+      hash = serializable_hash
+      hash[:facets] = xml_facets
+
+      options = {}
+      options = args.first.merge(root: :search) if args.first.is_a?(Hash)
+
+      hash.to_xml(options)
+    end
+  end
+end