naranya_ecm-sdk 0.0.14 → 0.0.15

data/lib/naranya_ecm/models/content_version.rb

@@ -1,36 +1,57 @@
-require 'active_resource'
 
-module NaranyaEcm::Models
-  class ContentVersion < ::ActiveResource::Base
+module NaranyaEcm
+  class ContentVersion
 
-    class DescriptionTranslations < EmbeddedLocalizedHash;  end
-
-    include NaranyaEcm::Behaviors::Resourceable
+    include NaranyaEcm.document_module
     include NaranyaEcm::Behaviors::Timestampable
+    include NaranyaEcm::Cache::Methods
+    include NaranyaEcm::Behaviors::Mediable
+
+    # Description (localized):
+    # A localized string that describes an overview of the significant changes
+    # particular in this version. Used to list the most significant updates, fixes, etc.
+    # to the end user.
+    field :description, type: String, localize: true
+
+    # tomar lifecycle de content:
+    attr_accessor :lifecycle_name
+    #field :lifecycle_name, type: String
+
+    # Version Lifecycle State:
+    # A managed string that describes the current state of this particular version.
+    # Depending on the Content's lifecycle, it changes upon several events.
+    # - draft:
+    # - awaiting_validation:
+    # - validated:
+    # - invalidated:
+    # - published:
+    # - superceded:
+    field :lifecycle_state, type: String, default: -> { :draft }
+    validates :lifecycle_state, presence: true
+
+    # Version Code:
+    # An internal version number. This number is used only to determine whether one version is more recent than another, with higher numbers indicating more recent versions. This is not the version number shown to users; that number is set by the versionName attribute.
+    # The value must be set as an integer, such as "100". You can define it however you want, as long as each successive version has a higher number. For example, it could be a build number. Or you could translate a version number in "x.y" format to an integer by encoding the "x" and "y" separately in the lower and upper 16 bits. Or you could simply increase the number by one each time a new version is released.
+    field :code, type: Integer
+    validates :code, presence: true, format: { with: /[0-9]+/ }
+
+    # Version Name:
+    # The version number shown to users.
+    # The string has no other purpose than to be displayed to users. The Version Code
+    # attribute holds the significant version number used internally.
+    field :name, type: String
+
+    # Content
+    # The content to which this particular version belongs:
+    belongs_to :content, class_name: :Content, inverse_of: :versions
     
-    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
-
-    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"
-
-    before_save :filter_out_read_only_attributes
-    def filter_out_read_only_attributes
-      %w(lifecycle_name content media_resources url created_at updated_at).each do |roa|
-        self.attributes.delete roa
-      end
-    end
-
-    #include NaranyaEcm::Lifecycles::Lifecycleable
-    # include NaranyaEcm::Lifecycles::VersionLifecycle
+    # MediaResources:
+    # A list of media - images, audio, video, etc. associated
+    # directly to this particular content version. Some examples:
+    # - Icons, Banners, screenshots, gallery images
+    has_many :media_resources, class_name: :MediaResource, inverse_of: :content_version
 
+    include NaranyaEcm::ContentLifecycle
+    
   end
 end

data/lib/naranya_ecm/models/download_authorization.rb

@@ -1,41 +1,37 @@
-require 'active_resource'
 
-module NaranyaEcm::Models
-  class DownloadAuthorization < ActiveResource::Base
+module NaranyaEcm
+  class DownloadAuthorization
 
-    include NaranyaEcm::Cache::Methods
-
-    class Tokens < HashWithIndifferentAccess
-      def initialize(*args)
-        super()
-        given_attrs = args.shift
-        given_attrs.each { |k,v| self[k] = v } unless given_attrs.nil?
-      end
-      def to_query_params
-        self.map { |key, value| "#{key}=#{value}" }.join '&'
-      end
-    end
-
-    include NaranyaEcm::Behaviors::Resourceable
+    include NaranyaEcm.document_module
     include NaranyaEcm::Behaviors::Timestampable
+    include NaranyaEcm::Cache::Methods
 
-    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"
+    belongs_to :media_resource
+    # validates :media_resource, presence: true
+    
+    field :expires_at,  type: DateTime, default: -> { 5.minutes.from_now }
+    field :tokens,      type: Hash
 
     def authorized_url
       unless @authorized_url
         uri = URI(self.media_resource.downloadable_url)
-        uri.query = self.tokens.to_query_params
+        uri.query = self.tokens.map { |key, value| "#{key}=#{value}" }.join '&'
         @authorized_url = uri.to_s
       end
       @authorized_url
     end
 
+    # validate :requested_media_resource_is_private
+    # def requested_media_resource_is_private
+    #   errors.add :media_resource, "must be private" unless self.media_resource.private?
+    # end
+
+    # validate :requested_media_resource_is_valid
+    # def requested_media_resource_is_valid
+    #   unless self.media_resource.valid?
+    #     errors.add :media_resource, self.media_resource.errors.messages
+    #   end
+    # end
+    
   end
 end

data/lib/naranya_ecm/models/media_resource.rb

@@ -1,28 +1,62 @@
-require 'active_resource'
 
-module NaranyaEcm::Models
-  class MediaResource < ActiveResource::Base
+module NaranyaEcm
+  class MediaResource
 
-    include NaranyaEcm::Behaviors::Resourceable
+    include NaranyaEcm.document_module
     include NaranyaEcm::Behaviors::Timestampable
+    include NaranyaEcm::Cache::Methods
 
-    class CompatibleDeviceOses < EmbeddedHash; end
+    # Media MIME/Internet Type:
+    field :type, type: String
 
-    include NaranyaEcm::Cache::Methods
+    # The roles of the media file (screenshot, icon, main_downloadable):
+    field :roles, type: Array, default: -> {[]}
+
+    # The URL to the downloadable file:
+    field :downloadable_url,  type: String
+    validates :downloadable_url, presence: true, format: { with: URI.regexp }
 
-    self.include_root_in_json = true
+    # The access type of the media file (private|public)
+    field :access_type, type: String, default: -> { 'public' }
+    validates :access_type, presence: true
+    
+    # The list of compatible device ids:
+    field :compatible_device_ids, type: Array, default: -> { [] }
 
-    # Definir los atributos conocidos:
-    schema do
-      # define each attribute separately
-      string :id, :access_type, :type, :roles, :downloadable_url
+    # The list of compatible device operating systems:
+    field :compatible_device_oses, type: Hash, default: -> { {} }
 
-      # unsupported types should be left as strings
-      # overload the accessor methods if you need to convert them
-      attribute 'compatible_device_ids',          'string'
-      attribute 'compatible_device_oses',         'string'
+    belongs_to :content
+    belongs_to :content_version
+    belongs_to :category
 
+    def private?
+      self.access_type == 'private'
     end
 
+    # Media Resource State:
+    # A managed string that describes the current state of this particular media.
+    # - unlinked: The media resource is linked to a category, content or content_version.
+    # - linked: The media resource is detached from any associated document.
+    field :state, type: String, default: -> { :unlinked }
+    validates :state, presence: true
+    state_machine :state, initial: :unlinked do
+      
+      state :linked
+      state :unlinked
+      
+      event :unlink do
+        transition :linked => :unlinked
+      end
+      
+      after_transition :on => any, do: :commit_state_change!
+    end
+
+    def commit_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/rest/associations.rb

@@ -0,0 +1,156 @@
+module NaranyaEcm::Rest
+
+  module Associations
+    extend ActiveSupport::Concern
+
+    class Association
+      attr_reader :klass, :name, :associated_class, :options
+
+      def resolve_class_name(given_class_name)
+        given_class_name = "#{@klass.name.deconstantize}::#{given_class_name}" if given_class_name.is_a?(Symbol)
+        given_class_name.constantize
+      end
+      
+      def initialize(klass, name, options = {})
+        @klass, @name = klass, name
+
+        @associated_class = if (given_class_name = options.delete(:class_name))
+          resolve_class_name(given_class_name)
+        else
+          resolve_class_name(name.to_s.classify.to_sym)
+        end
+
+        @options = options.with_indifferent_access
+
+        klass.send :attr_accessor, name
+        
+      end
+    end
+
+    class CollectionAssociation < Association
+    end
+
+    class SingularAssociation < Association
+    end
+
+    class HasMany < Association
+      def foreign_key
+        @foreign_key ||= @options[:foreign_key] || @options.has_key?(:inverse_of) ? "#{@options[:inverse_of]}_id".to_sym : "#{@klass.name.demodulize.underscore}_id".to_sym
+      end
+      def initialize(klass, name, options = {})
+        super
+        # Define the Getter:
+        klass.send :define_method, name do
+          value = self.instance_variable_get "@#{name}".to_sym
+          if value.nil?
+            reflection = self.class.reflect_on_association name
+            foreign_key = (self.class.name.demodulize.underscore + '_id').to_sym
+            value = self.instance_variable_set(
+              "@#{name}".to_sym,
+              reflection.associated_class.where(foreign_key => self.id)
+            )
+          end
+          value
+        end
+
+        # Define the setter
+        klass.send :define_method, "#{name}=".to_sym do |new_value|
+          reflection = self.class.reflect_on_association(name)
+          relation = Relation.new(reflection.associated_class, { reflection.foreign_key => self.id })
+
+          unless new_value.blank?
+            relation.load new_value
+          end
+          
+          instance_variable_set "@#{name}".to_sym, relation
+        end
+      end
+      def macro; :has_many; end
+    end
+
+    class HasOne < SingularAssociation
+      def initialize(klass, name, options = {})
+        super
+        # Set the Getter:
+        klass.send :define_method, name do
+          value = self.instance_variable_get "@#{name}".to_sym
+          if value.nil?
+            reflection = self.class.reflect_on_association name
+            foreign_key = (self.class.name.demodulize.underscore + '_id').to_sym
+            value = self.instance_variable_set(
+              "@#{name}".to_sym,
+              reflection.associated_class.where(foreign_key => self.id).first
+            )
+          end
+          value
+        end
+      end
+      def macro; :has_one; end
+    end
+
+    class BelongsTo < SingularAssociation
+      def initialize(klass, name, options = {})
+        super
+
+        # Define the foreign key:
+        klass.send :field, foreign_key, foreign_key: true
+
+        # Define the setter
+        klass.send :define_method, "#{name}=".to_sym do |new_value|
+          reflection = self.class.reflect_on_association(name)
+          foreign_key_name = reflection.foreign_key
+
+          new_value = reflection.associated_class.load new_value if new_value.is_a? Hash
+          raise "Type Mismatch on #{self.class.name} ##{name}= #{new_value.inspect}" unless new_value.nil? || new_value.class == reflection.associated_class
+
+          self.send "#{foreign_key_name}=".to_sym, new_value.nil? ? nil : new_value.id
+          instance_variable_set "@#{name}".to_sym, new_value
+        end
+      end
+      def macro; :belongs_to; end
+      def foreign_key
+        @foreign_key ||= options[:foreign_key] || "#{name}_id".to_sym
+      end
+    end
+
+    def is_association?(association_name)
+      self.class.is_association? association_name
+    end
+
+    module ClassMethods
+
+      def is_association?(association_name)
+        associations.has_key? association_name
+      end
+
+      def has_many(name, options={})
+        associations[name] = HasMany.new self, name, options
+      end
+
+      def has_one(name, options={})
+        associations[name] = HasOne.new self, name, options
+      end
+
+      def belongs_to(name, options={})
+        associations[name] = BelongsTo.new self, name, options
+      end
+
+      def reflect_on_association(association_name)
+        raise "Association #{name} does not exist" unless is_association? association_name
+        associations[association_name]
+      end
+
+      def reflect_on_all_associations
+        associations
+      end
+
+      private
+
+        def associations
+          @associations ||= {}.with_indifferent_access
+        end
+
+    end
+  end
+
+end

data/lib/naranya_ecm/rest/client.rb

@@ -0,0 +1,4 @@
+module NaranyaEcm::Rest
+  class Client
+  end
+end

data/lib/naranya_ecm/rest/errors.rb

@@ -0,0 +1,53 @@
+module NaranyaEcm::Rest
+  # = REST Errors
+  #
+  # Generic REST exception class.
+  class RestError < StandardError
+  end
+
+  # Raised when an object assigned to an association has an incorrect type.
+  #
+  #   class Ticket < ActiveRecord::Base
+  #     has_many :patches
+  #   end
+  #
+  #   class Patch < ActiveRecord::Base
+  #     belongs_to :ticket
+  #   end
+  #
+  #   # Comments are not patches, this assignment raises AssociationTypeMismatch.
+  #   @ticket.patches << Comment.new(content: "Please attach tests to your patch.")
+  class AssociationTypeMismatch < RestError
+  end
+
+  # Raised when unserialized object's type mismatches one specified for serializable field.
+  class SerializationTypeMismatch < RestError
+  end
+
+  # Raised when adapter not specified on connection (or configuration file <tt>config/database.yml</tt>
+  # misses adapter field).
+  class AdapterNotSpecified < RestError
+  end
+
+  # Raised when REST cannot find database adapter specified in <tt>config/database.yml</tt> or programmatically.
+  class AdapterNotFound < RestError
+  end
+
+  # Raised when connection to the database could not been established (for example when <tt>connection=</tt>
+  # is given a nil object).
+  class ConnectionNotEstablished < RestError
+  end
+
+  # Raised when REST cannot find record by given id or set of ids.
+  class ResourceNotFound < RestError
+  end
+
+  # Raised by ActiveRecord::Base.save! and ActiveRecord::Base.create! methods when record cannot be
+  # saved because record is invalid.
+  class ResourceNotSaved < RestError
+  end
+
+  # Raised by ActiveRecord::Base.destroy! when a call to destroy would return false.
+  class ResourceNotDestroyed < RestError
+  end
+end

data/lib/naranya_ecm/rest/finder_methods.rb

@@ -0,0 +1,50 @@
+require 'naranya_ecm/rest/errors'
+module NaranyaEcm::Rest
+
+  module FinderMethods
+
+    def find(*args)
+      if block_given?
+        to_a.find { |*block_args| yield(*block_args) }
+      else
+        find_with_ids(*args)
+      end
+    end
+
+    protected
+
+      def find_with_ids(*ids)
+        expects_array = ids.first.kind_of?(Array)
+        return ids.first if expects_array && ids.first.empty?
+
+        ids = ids.flatten.compact.uniq
+
+        case ids.size
+        when 0
+          raise ResourceNotFound, "Couldn't find #{self.name} without an ID"
+        when 1
+          result = find_one(ids.first)
+          expects_array ? [ result ] : result
+        else
+          find_some(ids)
+        end
+      end
+
+      def find_one(id)
+        self.load fetch_one(id)
+      end
+
+      def fetch_one(id)
+        format = NaranyaEcm.options[:format] || 'json'
+
+        response = self.get("#{path}/#{id}.#{format}")
+
+        case response.code
+        when 404
+          raise ResourceNotFound
+        when 200
+          response.to_hash
+        end
+      end
+  end
+end