naranya_ecm-sdk 0.0.14 → 0.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab5a255c31cbc5ece70b173939a3d883331e2355
-  data.tar.gz: aa2552ae589d918f381ca929784704e7119e5fcc
+  metadata.gz: 3f6a90236bd794d754bdf445805afdf1b4539d4f
+  data.tar.gz: e40ad3616ae04fb8932e2df7fb47546efb0ce7b1
 SHA512:
-  metadata.gz: 7329e2ad01e89a35391762dc82923953bf813de13ff4378de9dd59a696803d36d02920f74db48cb311c42da8ba8f22ccccde0344fcbfd1dd45ad2f5a7952c3cb
-  data.tar.gz: c462661938efd0c6f57dc24822500374f46c7f5368df99a8440d3479df1699f91582151dddb0eb89b863a0792c45152a6b3d4d5424e81d871f75a58f65fb3345
+  metadata.gz: f0802bf180226d3b443697ab502f09e1b13a23dd79105b246419de9a8e534cdc4db8351b6577953551ad3e8361c3a67a61e35c896509266c2309affbb9458f3a
+  data.tar.gz: 62565940d9f2025491f2a5d30d45990e1a2744afa2b411feb8c0bd1ebb5b766a4bd92b87b0127a22e098e6619686379318762f725dcabc8f163f86443316fc9b

data/lib/naranya_ecm/behaviors/localizable.rb

@@ -1,41 +1,37 @@
 require 'active_support/concern'
 
-module NaranyaEcm
+module NaranyaEcm::Behaviors
+  module Localizable
 
-  module Behaviors
-    module Localizable
+    extend ActiveSupport::Concern
 
-      extend ActiveSupport::Concern
+    included do
+      # Delegar el acceso tipo "Enumerable":
+      delegate :any?, to: :@attributes
 
-      included do
-        # 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"
 
-        # Re-establece el acceso tipo Hash:
-        delegate :[],   to: :@attributes
-        delegate :[]=,  to: :@attributes
-        self.site = "http://www.example.com"
-
-        attribute_name = self.name.demodulize.underscore[0..-("_translations".length+1)]
-        alias_method attribute_name.to_sym, :lookup
-      end
+      attribute_name = self.name.demodulize.underscore[0..-("_translations".length+1)]
+      alias_method attribute_name.to_sym, :lookup
+    end
 
-      def locales
-        @attributes.keys
-      end
-      alias_method :available_locales, :locales
-
-      def lookup
-        locale = ::I18n.locale
-        if ::I18n.respond_to?(:fallbacks)
-          lookup_result = @attributes[::I18n.fallbacks[locale].map(&:to_s).find{ |loc| @attributes.has_key?(loc) }]
-        else
-          lookup_result = @attributes[locale.to_s]
-        end
-        lookup_result || @attributes.present? ? @attributes.first[1] : nil
+    def locales
+      @attributes.keys
+    end
+    alias_method :available_locales, :locales
+
+    def lookup
+      locale = ::I18n.locale
+      if ::I18n.respond_to?(:fallbacks)
+        lookup_result = @attributes[::I18n.fallbacks[locale].map(&:to_s).find{ |loc| @attributes.has_key?(loc) }]
+      else
+        lookup_result = @attributes[locale.to_s]
       end
-
+      lookup_result || @attributes.present? ? @attributes.first[1] : nil
     end
-  end
 
-end
+  end
+end

data/lib/naranya_ecm/behaviors/mediable.rb

@@ -0,0 +1,25 @@
+module NaranyaEcm::Behaviors
+  module Mediable
+
+    extend ActiveSupport::Concern
+
+    def find_media_by_role(role_name)
+      mr = self.media_resources.nil? ? [] : self.media_resources
+      mr.detect { |mr| mr.roles.include? role_name }
+    end
+
+    def find_media_url_by_role(role_name)
+      mr = self.find_media_by_role role_name
+      mr.present? ? mr.downloadable_url : nil
+    end
+
+    def select_media_by_role(role_name)
+      self.media_resources.select { |mr| mr.roles.include? role_name }
+    end
+
+    def select_media_urls_by_role(role_name)
+      mr = self.select_media_by_role(role_name).map(&:downloadable_url)
+      mr.flatten.uniq
+    end
+  end
+end

data/lib/naranya_ecm/behaviors/timestampable.rb

@@ -1,22 +1,25 @@
 require 'active_support/concern'
-module NaranyaEcm
-  module Behaviors
-    module Timestampable
 
-      extend ActiveSupport::Concern
+module NaranyaEcm::Behaviors
+  module Timestampable
 
-      included do
-        %w(created_at updated_at).map(&:to_sym).each do |attr_sym|
-          # getter:
-          define_method(attr_sym) { @attributes[attr_sym].present? ? @attributes[attr_sym].to_datetime : nil }
-          # 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
+    extend ActiveSupport::Concern
+
+    included do
+      [:created_at, :updated_at].each do |timestamp_name|
+        attr_accessor timestamp_name
+        
+        define_method timestamp_name do
+          unless instance_variable_get("@#{timestamp_name}".to_sym).respond_to? :strftime
+            instance_variable_set(
+              "@#{timestamp_name}".to_sym,
+              instance_variable_get("@#{timestamp_name}".to_sym).to_s.to_datetime
+            )
+          end
+          instance_variable_get("@#{timestamp_name}".to_sym)
         end
       end
-
     end
+
   end
-end
+end

data/lib/naranya_ecm/cache/key.rb

@@ -1,73 +1,49 @@
 require 'active_support/hash_with_indifferent_access'
 
-module NaranyaEcm
-  module Cache
-    class Key < String
+module NaranyaEcm::Cache
+  class Key < String
 
-      TIMESTAMP_FORMAT = '%Y%m%d%H%M%S'.freeze
+    TIMESTAMP_FORMAT = '%Y%m%d%H%M%S'.freeze
 
-      def initialize(segments={})
+    attr_reader :klass, :id, :timestamp
 
-        @segments = ActiveSupport::HashWithIndifferentAccess.new
+    def initialize(given_class, given_id, given_timestamp = nil)
+      @klass, @id = given_class, given_id
 
-        resource = segments.delete :resource
-
-        @segments[:class_name] = case
-        when resource.present? then resource.class.name
-        when segments.has_key?(:class_name) then segments.delete(:class_name)
-        when segments.has_key?(:resource_class) then segments.delete(:resource_class).name
-        else nil
-        end
-
-        @segments[:id] = case
-        when resource.present?                then resource.id
-        when segments.has_key?(:id)           then segments.delete(:id)
-        else nil
-        end
-
-        @segments[:timestamp] = case
-        when resource.present? then resource.respond_to?(:updated_at) ? resource.updated_at : nil
-        when segments.has_key?(:timestamp) then segments.delete(:timestamp)
-        else nil
+      unless given_timestamp.blank?
+        @timestamp = if given_timestamp.is_a? String
+          given_timestamp.to_datetime
+        elsif given_timestamp.respond_to? :strftime
+          given_timestamp
+        else
+          raise ArgumentError, "Given timestamp is not a Date|Time like object" 
         end
-
-        @segments.freeze
-
-        super self.class.join_segments(@segments).freeze
-
       end
 
-      def class_name; @segments[:class_name]; end
-      def id;         @segments[:id];         end
-      def timestamp;  @segments[:timestamp];  end
+      super join_segments
+    end
 
-      def timestamped?
-        resource_timestamp.present?
-      end
+    def timestamped?
+      timestamp.present?
+    end
 
-      def any_timestamp
-        self.class.join_segments(@segments.except(:timestamp)) + '-*'
-      end
+    def exist?
+      NaranyaEcm.cache.exist? self
+    end
 
-      def with_timestamp(datetime)
-        raise "Not a valid timestamp" unless datetime.respond_to? :to_time
-        self.class.new class_name: class_name, id: id, timestamp: datetime
-      end
+    def read
+      NaranyaEcm.cache.read self
+    end
 
-      class << self
-        def join_segments(segments)
-          segments = segments.with_indifferent_access
-          str = segments[:class_name].tableize
-          if segments[:id].present?
-            str += "/#{segments[:id]}"
-            if segments[:timestamp].present? and segments[:timestamp].respond_to?(:to_time)
-              str += '-' + segments[:timestamp].strftime(TIMESTAMP_FORMAT)
-            end
-          end
-          str
-        end
+    def write(data)
+      NaranyaEcm.cache.write self, data
+    end
+
+    private
+      def join_segments
+        key = "#{klass.name.tableize}/#{id}"
+        timestamped? ? "#{key}-#{timestamp.strftime(TIMESTAMP_FORMAT)}" : key
       end
 
-    end
   end
 end

data/lib/naranya_ecm/cache/methods.rb

@@ -1,82 +1,69 @@
 require 'active_support/concern'
-module NaranyaEcm
-  module Cache
-    module Methods
 
-      extend ActiveSupport::Concern
+module NaranyaEcm::Cache
+  module Methods
 
-      included do
-        alias_method_chain :load, :caching
+    extend ActiveSupport::Concern
 
-        class << self
-          alias_method_chain :find_single, :caching
-        end
-      end
-
-      def cache_key
-        @cache_key ||= NaranyaEcm.cache_key_for resource: self
-      end
-
-      def load_with_caching(attributes, remove_root = false, persisted = false)
-        if self.new?
-          load_without_caching(attributes, remove_root, persisted)
-        else
-          res = load_without_caching(attributes, remove_root = false, persisted = false)
-          
-          cache_options = {}
-          cache_options[:expires_in] = 10.minutes unless self.updated_at.present? and self.updated_at.is_a? DateTime
-          
-          NaranyaEcm.cache.write cache_key, @attributes, cache_options
-        
-          res
-        end
+    included do
+      class << self
+        alias_method_chain :find,     :caching
+        alias_method_chain :find_one, :caching
       end
+    end
 
-      module ClassMethods
+    def cache_key
+      self.new_resource? ? nil : self.class.cache_key_for(self.id, self.updated_at)
+    end
 
-        def cache
-          NaranyaEcm.cache
-        end
+    module ClassMethods
 
-        def cache_key_for(attributes)
-          NaranyaEcm.cache_key_for attributes.merge(resource_class: self)
-        end
+      def cache
+        NaranyaEcm.cache
+      end
 
-        def find_cached(cache_key)
-          cached_attributes = cache.read(cache_key)
-          cached_attributes.present? ? instantiate_record(cached_attributes) : nil
-        end
+      def cache_key_for(id, timestamp=nil)
+        Key.new self, id, timestamp
+      end
 
-        def find_cached!(cache_key)
-          found = find_cached(cache_key)
-          raise "No record matched given attribute in cache" unless found
-          found
-        end
+      def find_with_caching(id, cache_options = {})
+        find_one_with_caching(id, cache_options)
+      end
 
-        private
+      private
 
-          # Find a single resource from the default URL
-          def find_single_with_caching(scope, options)
-            
+        # Find a single resource from the default URL
+        def find_one_with_caching(id, cache_options = {})
+          fetched_data = nil
+          missed = true
+          
+          # Ver primero si lo podemos obtener del cache:
+          cache_timestamp = cache_options.delete(:timestamp)
+          if cache_timestamp.present?
             # Try to load the record from cache:
-            cache_key = cache_key_for id: scope, timestamp: options.delete(:timestamp)
-            
-            record = find_cached cache_key
-            
-            unless record.present?
+            cache_key = cache_key_for(id, cache_timestamp)
+            missed = (fetched_data = cache_key.read).nil?
+            puts "===== CACHE #{(missed ? 'MISS: ' : 'HIT:  ')} '#{cache_key}'"
+          end
 
-              # Load the record from the ECM server:
-              record = find_single_without_caching(scope, options)
+          # Si no lo obtuvimos del caché, traer uno del server:
 
-              # Cache the record by writing the record's attributes to the cache store,
-              # IF the attributes have not been written before:
-              cache.write(record.cache_key, record.attributes) unless cache.exist? record.cache_key
-            end
-            
-            record
+          unless fetched_data.present?
+            fetched_data = fetch_one(id) 
+          end
+          
+          # Inicializar el recurso con los datos obtenidos:
+          resource = self.load fetched_data
+
+          # Write unless data exists:
+          if missed
+            puts "===== Cache WRITE: '#{resource.cache_key}'"
+            cache.write(resource.cache_key, fetched_data)
           end
-      end
 
+          resource
+        end
     end
+
   end
-end
+end

data/lib/naranya_ecm/lifecycles/content_lifecycle.rb

@@ -2,35 +2,58 @@ require 'active_support/concern'
 require 'state_machine'
 
 module NaranyaEcm
-  module Lifecycles
 
-    module ContentLifecycle
-      extend ActiveSupport::Concern
+  module ContentLifecycle
+    extend ActiveSupport::Concern
 
-      included do
+    included do
 
-        include NaranyaEcm::Lifecycles::Lifecycleable
+      state_machine :lifecycle_state, initial: :draft do
+        state :draft
+        state :awaiting_validation
+        state :accepted
+        state :rejected
+        state :published
+        state :inactive
 
-        ##################################################################
-        # StateMachine:
-        state_machine :lifecycle_state, initial: :draft do
+        event :send_to_validation do
+          transition :draft => :awaiting_validation
+        end
 
-          state :draft
+        event :accept do
+          transition :awaiting_validation => :accepted
+        end
 
-          state :awaiting_validation
+        event :reject do
+          transition [:awaiting_validation, :published] => :rejected
+        end
 
-          state :rejected
+        event :publish do
+          transition :draft => :published, if: :simple_lifecycle?
+          transition :accepted => :published, if: :validation_lifecycle? 
+        end
 
-          state :validated
+        event :deactivate do
+          transition any => :inactive
+        end
 
-          state :published
+        ######
+        after_transition :on => any, do: :commit_lifecycle_state_change!
+      end
 
-          state :deactivated
+       
+    end    
 
-        end
-      end
+    def simple_lifecycle?; self.lifecycle_name == 'simple'; end
+    def validation_lifecycle?; self.lifecycle_name == 'validation'; end
 
+    def commit_lifecycle_state_change!(transition)
+      off_band_changes["#{transition.attribute}_event"] = transition.event
+      self.send "reset_#{transition.attribute}!".to_sym
+      self.save
     end
 
+
   end
+
 end

data/lib/naranya_ecm/models/category.rb

@@ -1,40 +1,21 @@
-require 'active_resource'
 
-module NaranyaEcm::Models
-  class Category < ::ActiveResource::Base
-
-    include NaranyaEcm::Behaviors::Resourceable
+module NaranyaEcm
+  class Category
 
+    include NaranyaEcm.document_module
     include NaranyaEcm::Behaviors::Timestampable
-
-    include NaranyaEcm::Search::Methods
     include NaranyaEcm::Cache::Methods
+    include NaranyaEcm::Search::Methods
+    include NaranyaEcm::Behaviors::Mediable
 
-    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
+    field :code, type: String
+    validates :code, presence: true
 
-    delegate :name,        to: :name_translations
-    delegate :description,  to: :title_translations
+    field :name, type: String, localize: true
+    
+    has_many :media_resources
 
-    def contents
-      Content.find :all, params: { category_id: self.id }
-    end
+    has_many :contents
 
   end
 end

data/lib/naranya_ecm/models/content.rb

@@ -1,84 +1,84 @@
-require 'active_resource'
 
-module NaranyaEcm::Models
-  class Content < ::ActiveResource::Base
+module NaranyaEcm
+  class Content
 
-    include ActiveModel::Dirty
-
-    include NaranyaEcm::Behaviors::Resourceable
-
-    include NaranyaEcm::Search::Methods
+    include NaranyaEcm.document_module
+    include NaranyaEcm::Behaviors::Timestampable
     include NaranyaEcm::Cache::Methods
+    include NaranyaEcm::Search::Methods
+    include NaranyaEcm::Behaviors::Mediable
+
+    # Type:
+    # Describes the main type of the content - App, Note, etc.
+    field :type, type: String
+
+    # Content Lifecycle Name:
+    # Determines the lifecycle for the specific content:
+    # - simple:       draft -> published -> inactive
+    # - validatable:  draft -> awaiting_validation -> validated -> published -> inactive
+    # - expirable:    draft -> published -> expired/inactive
+    field :lifecycle_name, type: String, default: -> { 'simple' }
+    validates :lifecycle_name, presence: true
+
+    # Content Lifecycle State:
+    # A managed string that describes the current state of this particular content.
+    # Depending on the Content's lifecycle, it changes upon several events.
+    # - draft:
+    # - awaiting_validation:
+    # - validated:
+    # - invalidated:
+    # - published:
+    field :lifecycle_state, type: String, default: -> { :draft }
+    validates :lifecycle_state, presence: true
+
+    # Title (Localized):
+    # The content title that can be displayed as header, result, etc.
+    field :title, type: String, localize: true
+    validate :at_least_one_title_translation_must_exist
+
+    # Description (Localized):
+    # The content title that can be displayed as header, result, etc.
+    field :description, type: String, localize: true
     
-    class TitleTranslations       < EmbeddedLocalizedHash;  end
-    class DescriptionTranslations < EmbeddedLocalizedHash;  end
-    class ContentRating           < EmbeddedHash;           end
-
-    self.include_root_in_json = true
-
-    has_many    :versions,        class_name: "naranya_ecm/models/content_version"
-    belongs_to  :current_version, class_name: "naranya_ecm/models/content_version"
-
-    belongs_to  :category,        class_name: "naranya_ecm/models/category"
-
-    has_many    :media_resources, class_name: "naranya_ecm/models/media_resource"
-
-    # Definir los atributos conocidos:
-    schema do
-      # define each attribute separately
-      string :id, :type, :lifecycle_name, :lifecycle_state, :content_rating, :created_at, :updated_at
-      string :category_id
-      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'
-
-      if NaranyaEcm.options[:extra_attributes] && NaranyaEcm.options[:extra_attributes][:content]
-        NaranyaEcm.options[:extra_attributes][:content].each { |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
-
-    def initialize(attributes = {}, persisted = false)
-      super
-      attributes[:title_translations]       = TitleTranslations.new       unless attributes[:title_translations].present?
-      attributes[:description_translations] = DescriptionTranslations.new unless attributes[:description_translations].present?
-      attributes[:content_rating]           = ContentRating.new           unless attributes[:content_rating].present?
-    end
+    # Content Rating:
+    field :content_rating, type: Hash
+
+    # Keywords:
+    field :keywords, type: Array
+
+    # Author:
+    # The name of the user who created this content.
+    field :author, type: String
+    validates :author,
+      presence: true
+
+    # Main URL:
+    # The URL that should be used to render or display the content.
+    field :main_url, type: String
+    validates :main_url,
+      format: { with: URI.regexp },
+      allow_nil: true,
+      allow_blank: true
+
+    belongs_to :category
+
+    has_many :versions,
+        class_name: :ContentVersion
     
-    include NaranyaEcm::Behaviors::Timestampable
+    belongs_to :current_version,
+        class_name: :ContentVersion
 
-    before_save :keywords_array!
+    has_many :media_resources,
+        class_name: :MediaResource,
+        inverse_of: :content
     
-    def keywords_array!
-      unless self.attributes[:keywords].is_a?(Array)
-        self.attributes[:keywords] = if self.attributes[:keywords]=='' then []
-        else [self.attributes[:keywords]]
-        end
-      end
-    end
+    include NaranyaEcm::ContentLifecycle
 
-    #include NaranyaEcm::Lifecycles::ContentLifecycle
+    private
+
+      def at_least_one_title_translation_must_exist
+        errors.add :title_translations, "must have at least one translation" unless title_translations.keys.any?
+      end
     
   end
 end