naranya_ecm-sdk 0.0.4

data/lib/naranya_ecm/models/category.rb

@@ -0,0 +1,42 @@
+require 'active_resource'
+
+module NaranyaEcm
+  module Models
+    class Category < ::ActiveResource::Base
+
+      include SiteFromConfiguration
+
+      include NaranyaEcm::Behaviors::Timestampable
+
+      include NaranyaEcm::Search::Methods
+      include NaranyaEcm::Cache::Methods
+
+      class NameTranslations < ::ActiveResource::Base
+        include NaranyaEcm::Behaviors::Localizable
+      end
+
+      self.include_root_in_json = true
+
+      # Definir los atributos conocidos:
+      schema do
+        # define each attribute separately
+        string :id, :code, :created_at, :updated_at
+
+        # unsupported types should be left as strings
+        # overload the accessor methods if you need to convert them
+        #attribute 'created_at', 'string'
+        attribute 'name_translations', 'string'
+        attribute 'description_translations', 'string'
+
+      end
+
+      delegate :name,        to: :name_translations
+      delegate :description,  to: :title_translations
+
+      def contents
+        Content.find :all, params: { category_id: self.id }
+      end
+
+    end
+  end
+end

data/lib/naranya_ecm/models/content.rb

@@ -0,0 +1,102 @@
+require 'active_resource'
+
+module NaranyaEcm
+  module Models
+    class Content < ::ActiveResource::Base
+
+      include ActiveModel::Dirty
+
+      include SiteFromConfiguration
+
+      include NaranyaEcm::Search::Methods
+      include NaranyaEcm::Cache::Methods
+      
+      #include HasManyPatch
+
+      class TitleTranslations < ::ActiveResource::Base
+        include NaranyaEcm::Behaviors::Localizable
+      end
+
+      class DescriptionTranslations < ::ActiveResource::Base
+        include NaranyaEcm::Behaviors::Localizable
+      end
+
+      class ContentRating < HashWithIndifferentAccess
+        def initialize(*args)
+          super()
+          given_attrs = args.shift
+          given_attrs.each { |k,v| self[k] = v } unless given_attrs.nil?
+        end
+      end
+
+      self.include_root_in_json = true
+
+      has_many :versions, class_name: "naranya_ecm/models/content_version"
+
+      has_one :current_version, class_name: "naranya_ecm/models/content_version"
+      belongs_to :category, class_name: "naranya_ecm/models/category"
+
+      # Definir los atributos conocidos:
+      schema do
+        # define each attribute separately
+        string :id, :type, :lifecycle_name, :lifecycle_state, :content_rating, :created_at, :updated_at
+
+        string :author
+        string :main_url
+
+        # unsupported types should be left as strings
+        # overload the accessor methods if you need to convert them
+        #attribute 'created_at', 'string'
+        attribute 'title_translations', 'string'
+        attribute 'description_translations', 'string'
+        attribute 'keywords', 'string'
+
+        attribute 'media_resources', 'string'
+        attribute 'current_version', 'string'
+
+        # Extra attributes:
+        NaranyaEcm.options['extra_attributes']['content'].each do |key, val|
+          attribute key, val
+        end
+
+      end
+
+      schema_attrs = self.schema.keys.map(&:to_sym)
+      define_attribute_methods(*schema_attrs)
+      schema_attrs.each do |attr_sym|
+        # getter:
+        define_method(attr_sym) { @attributes[attr_sym] }
+        # setter:
+        define_method("#{attr_sym}=".to_sym) do |value|
+          self.send "#{attr_sym}_will_change!".to_sym unless value == @attributes[attr_sym]
+          @attributes[attr_sym] = value
+        end
+      end
+
+      delegate :title,        to: :title_translations
+      delegate :description,  to: :description_translations
+      
+      include NaranyaEcm::Behaviors::Timestampable
+      
+      # include NaranyaEcm::Lifecycles::Lifecycleable
+      # ##################################################################
+      # # StateMachine:
+      # state_machine :lifecycle_state, initial: :draft do
+
+      #   state :draft
+
+      #   state :awaiting_validation
+
+      #   state :rejected
+
+      #   state :validated
+
+      #   state :published
+
+      #   state :deactivated
+
+      # end
+      
+    end
+  end
+end

data/lib/naranya_ecm/models/content_version.rb

@@ -0,0 +1,38 @@
+require 'active_resource'
+
+module NaranyaEcm
+  module Models
+    class ContentVersion < ::ActiveResource::Base
+
+      include SiteFromConfiguration
+      include NaranyaEcm::Behaviors::Timestampable
+      
+      self.include_root_in_json = true
+
+      # Definir los atributos conocidos:
+      schema do
+        # define each attribute separately
+        string :id, :name, :lifecycle_name, :lifecycle_state
+
+        integer :code
+
+      end
+
+      class DescriptionTranslations < ::ActiveResource::Base
+        include NaranyaEcm::Behaviors::Localizable
+      end
+      
+      delegate :description,  to: :description_translations
+
+      belongs_to :content,
+        class_name: "naranya_ecm/models/content"
+      
+      has_many :media_resources,
+        class_name: "naranya_ecm/models/media_resource"
+
+      #include NaranyaEcm::Lifecycles::Lifecycleable
+      # include NaranyaEcm::Lifecycles::VersionLifecycle
+
+    end
+  end
+end

data/lib/naranya_ecm/models/download_authorization.rb

@@ -0,0 +1,55 @@
+require 'active_resource'
+
+module NaranyaEcm
+  module Models
+    class DownloadAuthorization < ActiveResource::Base
+
+      class Tokens < ::ActiveResource::Base
+        # Delegar el acceso tipo "Enumerable":
+        delegate :any?, to: :@attributes
+
+        # Re-establece el acceso tipo Hash:
+        delegate :[],   to: :@attributes
+        delegate :[]=,  to: :@attributes
+        self.site = "http://www.example.com"
+
+        def to_query_params
+          @attributes.map { |key, value| "#{key}=#{value}" }.join '&'
+        end
+      end
+
+      include SiteFromConfiguration
+      include NaranyaEcm::Behaviors::Timestampable
+
+      self.include_root_in_json = true
+
+      # Definir los atributos conocidos:
+      schema do
+        string :id, :media_resource_id, :expires_at, :tokens, :created_at, :updated_at
+      end
+
+      belongs_to :media_resource, class_name: "naranya_ecm/models/media_resource"
+
+      def media_resource=(given_media_resource)
+        @attributes[:media_resource_id] = given_media_resource.id
+      end
+
+      def initialize(attributes = {}, persisted = false)
+        if given_media_resource = attributes.delete(:media_resource)
+          attributes[:media_resource_id] = given_media_resource.id
+        end
+        super
+      end
+
+      def authorized_url
+        unless @authorized_url
+          uri = URI(self.media_resource.downloadable_url)
+          uri.query = self.tokens.to_query_params
+          @authorized_url = uri.to_s
+        end
+        @authorized_url
+      end
+
+    end
+  end
+end

data/lib/naranya_ecm/models/lifecycle.rb

@@ -0,0 +1,36 @@
+
+module NaranyaEcm
+  module Models
+
+    # Value Object de Lifecycle de documentos / versiones / media / etc.
+    class Lifecycle < String
+      include Comparable
+
+      KNOWN_LIFECYCLES = %w(simple validatable)
+        .map { |m| m.to_sym }
+        .freeze
+
+      def is_lifecycle?(given_lifecycle)
+        given_lifecycle.to_s == self
+      end
+
+      KNOWN_LIFECYCLES.each do |lifecycle_name|
+        define_method("is_#{lifecycle_name}?") do
+          is_lifecycle?(lifecycle_name)
+        end
+      end
+
+      def method_missing(method_name, *args, &block)
+        if method_name.to_s =~ /^is_(\w+)\?$/
+          is_lifecycle?($1)
+        else
+          super # You *must* call super if you don't handle the
+                # method, otherwise you'll mess up Ruby's method
+                # lookup.
+        end
+      end
+
+    end
+
+  end
+end

data/lib/naranya_ecm/models/media_resource.rb

@@ -0,0 +1,33 @@
+require 'active_resource'
+
+module NaranyaEcm
+  module Models
+    class MediaResource < ActiveResource::Base
+
+      include SiteFromConfiguration
+      include NaranyaEcm::Behaviors::Timestampable
+
+      self.include_root_in_json = true
+
+      # Definir los atributos conocidos:
+      schema do
+        # define each attribute separately
+        string :id, :access_type, :type, :role, :downloadable_url
+
+        string :author
+        string :main_url
+
+        # unsupported types should be left as strings
+        # overload the accessor methods if you need to convert them
+        #attribute 'created_at', 'string'
+        attribute 'created_at',                     'string'
+        attribute 'updated_at',                     'string'
+        attribute 'compatible_device_ids',          'string'
+        attribute 'compatible_device_oses',         'string'
+        attribute 'compatible_device_os_versions',  'string'
+
+      end
+
+    end
+  end
+end

data/lib/naranya_ecm/models.rb

@@ -0,0 +1,13 @@
+require 'active_support/dependencies/autoload'
+
+module NaranyaEcm
+  module Models
+    extend ActiveSupport::Autoload
+    autoload :Category
+    autoload :Content
+    autoload :ContentVersion
+    autoload :Lifecycle
+    autoload :DownloadAuthorization
+    autoload :MediaResource
+  end
+end

data/lib/naranya_ecm/search/hit.rb

@@ -0,0 +1,17 @@
+module NaranyaEcm
+  module Search
+    class Hit
+      attr_reader :id, :type, :updated_at, :order, :score
+      attr_accessor :cache_key
+      def initialize(attributes={})
+        @id         = attributes.delete :_id
+        @type       = attributes.delete :_type
+        @score      = attributes.delete :_score
+
+        source      = attributes.delete :_source
+        @updated_at = source.has_key?(:updated_at) ? source.delete(:updated_at).to_datetime : nil
+        @order      = attributes.delete :order
+      end
+    end
+  end
+end

data/lib/naranya_ecm/search/methods.rb

@@ -0,0 +1,26 @@
+require 'active_support/concern'
+module NaranyaEcm
+  module Search
+    module Methods
+      extend ActiveSupport::Concern
+
+      included do
+        attr_reader :search_score, :search_order
+      end
+      
+      def merge_search_hit_data(hit)
+        @search_score, @search_order = hit.score, hit.order
+      end
+
+      module ClassMethods
+        def search(*args)
+          Results.new(*args, self)
+        end
+        def kick_search(terms, options={})
+          search(Query.build_searchkick_like(terms, options))
+        end
+      end
+
+    end
+  end
+end

data/lib/naranya_ecm/search/query.rb

@@ -0,0 +1,296 @@
+module NaranyaEcm
+  module Search
+    class Query < Hash
+      class << self
+        def build_searchkick_like(term, options = {})
+          if term.is_a?(Hash)
+            options = term
+            term = nil
+          else
+            term = term.to_s
+          end
+
+          fields =
+            if options[:fields]
+              if options[:autocomplete]
+                options[:fields].map{|f| "#{f}.autocomplete" }
+              else
+                options[:fields].map do |value|
+                  k, v = value.is_a?(Hash) ? value.to_a.first : [value, :word]
+                  "#{k}.#{v == :word ? "analyzed" : v}"
+                end
+              end
+            else
+              ["_all"]
+            end
+
+          operator = options[:partial] ? "or" : "and"
+
+          # model and eagar loading
+          load = options[:load].nil? ? true : options[:load]
+          load = (options[:include] ? {include: options[:include]} : true) if load
+
+          # pagination
+          page = [options[:page].to_i, 1].max
+          per_page = (options[:limit] || options[:per_page] || 10).to_i
+          offset = options[:offset] || (page - 1) * per_page
+
+          all = term == "*"
+
+          if options[:query]
+            payload = options[:query]
+          elsif options[:similar]
+            payload = {
+              more_like_this: {
+                fields: fields,
+                like_text: term,
+                min_doc_freq: 1,
+                min_term_freq: 1,
+                analyzer: "searchkick_search2"
+              }
+            }
+          elsif all
+            payload = {
+              match_all: {}
+            }
+          else
+            if options[:autocomplete]
+              payload = {
+                multi_match: {
+                  fields: fields,
+                  query: term,
+                  analyzer: "searchkick_autocomplete_search"
+                }
+              }
+            else
+              queries = []
+              fields.each do |field|
+                if field == "_all" or field.end_with?(".analyzed")
+                  shared_options = {
+                    fields: [field],
+                    query: term,
+                    use_dis_max: false,
+                    operator: operator,
+                    cutoff_frequency: 0.001
+                  }
+                  queries.concat [
+                    {multi_match: shared_options.merge(boost: 10, analyzer: "searchkick_search")},
+                    {multi_match: shared_options.merge(boost: 10, analyzer: "searchkick_search2")}
+                  ]
+                  if options[:misspellings] != false
+                    distance = (options[:misspellings].is_a?(Hash) && options[:misspellings][:distance]) || 1
+                    queries.concat [
+                      {multi_match: shared_options.merge(fuzziness: distance, max_expansions: 3, analyzer: "searchkick_search")},
+                      {multi_match: shared_options.merge(fuzziness: distance, max_expansions: 3, analyzer: "searchkick_search2")}
+                    ]
+                  end
+                else
+                  queries << {
+                    multi_match: {
+                      fields: [field],
+                      query: term,
+                      analyzer: "searchkick_autocomplete_search"
+                    }
+                  }
+                end
+              end
+
+              payload = {
+                dis_max: {
+                  queries: queries
+                }
+              }
+            end
+
+          end
+
+          custom_filters = []
+
+          if options[:boost]
+            custom_filters << {
+              filter: {
+                exists: {
+                  field: options[:boost]
+                }
+              },
+              script: "log(doc['#{options[:boost]}'].value + 2.718281828)"
+            }
+          end
+
+          if custom_filters.any?
+            payload = {
+              custom_filters_score: {
+                query: payload,
+                filters: custom_filters,
+                score_mode: "total"
+              }
+            }
+          end
+
+          payload = {
+            query: payload,
+            size: per_page,
+            from: offset
+          }
+          payload[:explain] = options[:explain] if options[:explain]
+
+          # order
+          if options[:order]
+            order = options[:order].is_a?(Enumerable) ? options[:order] : {options[:order] => :asc}
+            payload[:sort] = Hash[ order.map{|k, v| [k.to_s == "id" ? :_id : k, v] } ]
+          end
+
+          term_filters =
+            proc do |field, value|
+              if value.is_a?(Array) # in query
+                if value.any?
+                  {or: value.map{|v| term_filters.call(field, v) }}
+                else
+                  {terms: {field => value}} # match nothing
+                end
+              elsif value.nil?
+                {missing: {"field" => field, existence: true, null_value: true}}
+              else
+                {term: {field => value}}
+              end
+            end
+
+          # where
+          where_filters =
+            proc do |where|
+              filters = []
+              (where || {}).each do |field, value|
+                field = :_id if field.to_s == "id"
+
+                if field == :or
+                  value.each do |or_clause|
+                    filters << {or: or_clause.map{|or_statement| {and: where_filters.call(or_statement)} }}
+                  end
+                else
+                  # expand ranges
+                  if value.is_a?(Range)
+                    value = {gte: value.first, (value.exclude_end? ? :lt : :lte) => value.last}
+                  end
+
+                  if value.is_a?(Hash)
+                    if value[:near]
+                      filters << {
+                        geo_distance: {
+                          field => value.delete(:near).map(&:to_f).reverse,
+                          distance: value.delete(:within) || "50mi"
+                        }
+                      }
+                    end
+
+                    if value[:top_left]
+                      filters << {
+                        geo_bounding_box: {
+                          field => {
+                            top_left: value.delete(:top_left).map(&:to_f).reverse,
+                            bottom_right: value.delete(:bottom_right).map(&:to_f).reverse
+                          }
+                        }
+                      }
+                    end
+
+                    value.each do |op, op_value|
+                      if op == :not # not equal
+                        filters << {not: term_filters.call(field, op_value)}
+                      elsif op == :all
+                        filters << {terms: {field => op_value, execution: "and"}}
+                      else
+                        range_query =
+                          case op
+                          when :gt
+                            {from: op_value, include_lower: false}
+                          when :gte
+                            {from: op_value, include_lower: true}
+                          when :lt
+                            {to: op_value, include_upper: false}
+                          when :lte
+                            {to: op_value, include_upper: true}
+                          else
+                            raise "Unknown where operator"
+                          end
+                        filters << {range: {field => range_query}}
+                      end
+                    end
+                  else
+                    filters << term_filters.call(field, value)
+                  end
+                end
+              end
+              filters
+            end
+
+          # filters
+          filters = where_filters.call(options[:where])
+          if filters.any?
+            payload[:filter] = {
+              and: filters
+            }
+          end
+
+          # facets
+          facet_limits = {}
+          if options[:facets]
+            facets = options[:facets] || {}
+            if facets.is_a?(Array) # convert to more advanced syntax
+              facets = Hash[ facets.map{|f| [f, {}] } ]
+            end
+
+            payload[:facets] = {}
+            facets.each do |field, facet_options|
+              # ask for extra facets due to
+              # https://github.com/elasticsearch/elasticsearch/issues/1305
+
+              if facet_options[:ranges]
+                payload[:facets][field] = {
+                  range: {
+                    field.to_sym => facet_options[:ranges]
+                  }
+                }
+              else
+                payload[:facets][field] = {
+                  terms: {
+                    field: field,
+                    size: facet_options[:limit] ? facet_options[:limit] + 150 : 100000
+                  }
+                }
+              end
+
+              facet_limits[field] = facet_options[:limit] if facet_options[:limit]
+
+              # offset is not possible
+              # http://elasticsearch-users.115913.n3.nabble.com/Is-pagination-possible-in-termsStatsFacet-td3422943.html
+
+              facet_filters = where_filters.call(facet_options[:where])
+              if facet_filters.any?
+                payload[:facets][field][:facet_filter] = {
+                  and: {
+                    filters: facet_filters
+                  }
+                }
+              end
+            end
+          end
+
+          # highlight
+          if options[:highlight]
+            payload[:highlight] = {
+              fields: Hash[ fields.map{|f| [f, {}] } ]
+            }
+            if options[:highlight].is_a?(Hash) and tag = options[:highlight][:tag]
+              payload[:highlight][:pre_tags] = [tag]
+              payload[:highlight][:post_tags] = [tag.to_s.gsub(/\A</, "</")]
+            end
+          end
+
+          payload[:_source] = 'updated_at'
+
+          self.new.merge payload
+        end
+      end
+    end
+  end
+end