naranya_ecm-sdk 0.0.42 → 0.0.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: edcb5360a556fa04739d34bda3fd6ae7e3f0a696
-  data.tar.gz: 6e2f6e3fe4f775b8e0df4a4c76c18299a5249740
+  metadata.gz: 183c574009558b2788b71cce8899e52e9a948344
+  data.tar.gz: d1ffcd41db7e78e43251c7714c7e7ec686223b15
 SHA512:
-  metadata.gz: 743f9b659c78a0b6c972092c032d81a0cd20e337ac2db8091ab4fbf57da82f731cc1f3932c27d279e1c4dd7c3e10e5d9790a841b68587523431c68b3342b884b
-  data.tar.gz: 8f1ef6a70618d0e6857ed2bbfe648c79cbece07e36268ab2a2eab8cfc87472e394e4ea0c3852be46ce92bed1f7f20ac028e7cf633644526fbb9f32fc26eb63b9
+  metadata.gz: c010113401ef577a7b24a41e50614c4d98c77c91eba374f421279e224aa2529fac258423b9e2d19f00451d7950a7dad90f8a7e209f2dee6ddc230a6a60dae6e7
+  data.tar.gz: 5fd603773082dbcd115d97e36b1ab9f68649c3ae3bd81b1e717ea43b32f87389fdda26188de350378337c133ebd2511fea3560c9cf6e49de44b4965521f90d70

data/.gitignore

@@ -10,4 +10,5 @@ spec/dummy/.sass-cache
 Gemfile.lock
 /naranya_ecm.yml
 /.irb*
-/naranya_ecm-sdk-*.gem
+/naranya_ecm-sdk-*.gem
+/*.env

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format documentation
+--require spec_helper

data/Gemfile

@@ -6,5 +6,4 @@ gemspec
 gem 'redis-activesupport'
 gem 'pry', require: 'pry'
 gem 'byebug'
-
-#gem 'activeresource', path: '../other/activeresource'
+gem "patron"

data/lib/aasm/persistence/rest_persistence.rb

@@ -32,7 +32,7 @@ module AASM
         base.send(:include, AASM::Persistence::RestPersistence::InstanceMethods)
 
         base.before_validation(:aasm_ensure_initial_state, :on => :create)
-        
+
         # ensure initial aasm state even when validations are skipped
         base.before_create(:aasm_ensure_initial_state)
 
@@ -108,18 +108,23 @@ module AASM
         # end
 
       private
-        
+
         def aasm_ensure_initial_state
           send("#{self.class.aasm_column}=", aasm.enter_initial_state.to_s) if send(self.class.aasm_column).blank?
         end
 
         def aasm_fire_event(name, options, *args, &block)
           local_success = super
-          
+
           if local_success
             data = { name: name, target_type: self.class.name.demodulize, target_id: self.id }
-            response = ::NaranyaEcm::Rest::Client.post "/events.json", body: { state_event: data }
-            remote_success = response.success?
+
+            response = NContent::SDK::RESTClient.post "/events.json" do |req|
+              req.headers[:content_type] = 'application/json'
+              req.body = ActiveSupport::JSON.encode(state_event: data)
+            end
+
+            remote_success = response.status < 400
             unless remote_success
             end
           end
@@ -131,4 +136,4 @@ module AASM
 
     end
   end
-end
+end

data/lib/naranya_ecm-sdk.rb

@@ -1,13 +1,14 @@
 require 'naranya_ecm-sdk/version'
 
 require 'active_support/time'
-require 'active_support/configurable'
 require 'active_support/dependencies/autoload'
 require 'active_support/core_ext/hash/indifferent_access.rb'
 require 'yaml'
 
 require 'fog/aws/storage' unless defined?(::Fog::AWS::Storage)
 
+require 'ncontent-sdk'
+
 module NaranyaEcm
 
   extend ActiveSupport::Autoload
@@ -22,7 +23,6 @@ module NaranyaEcm
   # that connects the NaranyaEcm models with the Naranya CaaS REST services.
   module Rest
     extend ActiveSupport::Autoload
-    autoload :Client
     autoload :Errors
     autoload :Persistence
     autoload :Associations
@@ -65,68 +65,7 @@ module NaranyaEcm
     autoload :Results
   end
 
-  include ActiveSupport::Configurable
-
-  DEFAULT_CONFIG = {
-    site: "http://ecm.naranya.net:5000",
-    client_notify_url: "http://www.example.com/naranya_ecm/notifications",
-    notification_processing_modules: []
-  }.freeze
-
-  class << self
-
-    def storage
-      @storage ||= Fog::Storage.new options[:storage].except(:root_directory)
-    end
-
-    def root_directory
-      @root_directory ||= storage.directories.get(options[:storage][:root_directory])
-    end
-
-    def setup; yield config; end
-    def document_module; NaranyaEcm::Rest::Model; end
-    def timestamp_module; NaranyaEcm::Behaviors::Timestampable; end
-
-    def options
-      auto_conf unless config.present?
-      config
-    end
-
-    def cache
-      auto_conf unless config.present?
-      @cache ||= ActiveSupport::Cache.lookup_store *options[:cache]
-    end
-
-    def logger
-      auto_conf unless config.present?
-      @logger ||= Logger.new($stdout)
-    end
-
-    def load_config_from_yml(yml_path, env="production")
-      raise "YAML file doesn't extst" unless File.exist?(yml_path)
-      yml_config = DEFAULT_CONFIG.merge(YAML::load(ERB.new(File.read(yml_path)).result)[env])
-        .with_indifferent_access
-      setup { |config| yml_config.each { |key, val| config.send "#{key}=".to_sym, val } }
-    end
-
-    protected
-
-    def auto_conf
-      # Cargar configuracion dentro del folder de config en Rails:
-      if defined?(Rails)
-        yml_path = File.join(Rails.root, 'config', 'naranya_ecm.yml')
-        load_config_from_yml(yml_path, Rails.env)
-
-        # Use the Rails cache:
-        @cache = Rails.cache
-
-        # Use the Rails logger:
-        @logger = Rails.logger
-      elsif File.exists?('./naranya_ecm.yml')
-        load_config_from_yml('./naranya_ecm.yml')
-      end
-    end
-
-  end
+  def self.document_module; NaranyaEcm::Rest::Model; end
+  def self.timestamp_module; NaranyaEcm::Behaviors::Timestampable; end
 
 end

data/lib/naranya_ecm-sdk/version.rb

@@ -1,3 +1,3 @@
 module NaranyaEcm
-  VERSION = "0.0.42"
+  VERSION = "0.0.43"
 end

data/lib/naranya_ecm/models/media_resource.rb

@@ -95,7 +95,7 @@ module NaranyaEcm
     # Returns the storage root directory, depending of the storage engine:
     # - Amazon AWS S3: A Fog::Storage::AWS::Directory object
     def self.root_directory
-      NaranyaEcm.root_directory
+      NContent::SDK.root_directory
     end
 
     def move_downloadable_to(path, force_move=false)

data/lib/naranya_ecm/models/notification.rb

@@ -16,8 +16,8 @@ module NaranyaEcm
     alias_method_chain :initialize, :attributes_hash
 
     def process
-      NaranyaEcm.logger.debug "NaranyaEcm::Notification: #{self.attributes}"
-      NaranyaEcm.logger.debug "NaranyaEcm::Notification: No processing implemented."
+      NContent::SDK.logger.debug "NaranyaEcm::Notification: #{self.attributes}"
+      NContent::SDK.logger.debug "NaranyaEcm::Notification: No processing implemented."
     end
 
     def method_missing(method, *args, &block)

data/lib/naranya_ecm/rest/errors.rb

@@ -14,14 +14,14 @@ module NaranyaEcm::Rest
     ##
     # Captura un response y genera + avienta una excepción.
     def self.raise_by_failed_response(response, message = "")
-      klass = case response.code
+      klass = case response.status
       when 401 then AuthorizationRequired
       when 403 then Forbidden
       when 404 then ResourceNotFound
       when 422 then UnprocessableEntity
       else RemoteFailed
       end
-      raise klass.new response, "Server responded with code #{response.code}. Message: #{message}"
+      raise klass.new response, "Server responded with code #{response.status}. Message: #{message}"
     end
 
   end
@@ -73,6 +73,19 @@ module NaranyaEcm::Rest
   end
 
   class AuthorizationRequired < RestError
+
+    def self.parse_www_authenticate_header(response)
+      Hash[response.headers['WWW-Authenticate'].scan(/(\w+)="([^"]+)"/)] \
+        if response.headers['WWW-Authenticate']
+    end
+
+    delegate :parse_www_authenticate_header, to: :class
+
+    def initialize(given_response, msg = "")
+      data = parse_www_authenticate_header given_response
+      super given_response,
+        "#{data['error_description']} (HTTP status #{given_response.status})"
+    end
   end
 
   class Forbidden < RestError
@@ -84,4 +97,4 @@ module NaranyaEcm::Rest
   class RemoteFailed < RestError
   end
 
-end
+end

data/lib/naranya_ecm/rest/finder_methods.rb

@@ -1,5 +1,4 @@
 require 'naranya_ecm/rest/errors'
-require 'naranya_ecm/rest/client'
 
 module NaranyaEcm::Rest
 
@@ -19,12 +18,13 @@ module NaranyaEcm::Rest
     protected
 
       def find_one(id)
-        self.load fetch_one(id)
+        found_resource = self.load fetch_one(id)
+        found_resource.instance_variable_set("@new_resource", false)
+        found_resource
       end
 
       def fetch_one(id)
-        format = NaranyaEcm.options[:format] || 'json'
-        Client.get("#{path}/#{id}.#{format}").to_hash
+        NContent::SDK::RESTClient.get("#{path}/#{id}.json").body
       end
   end
 end

data/lib/naranya_ecm/rest/model.rb

@@ -50,7 +50,7 @@ module NaranyaEcm::Rest
     end
 
     extend ActiveSupport::Concern
-    
+
     included do
 
       include ActiveModel::Model
@@ -66,14 +66,16 @@ module NaranyaEcm::Rest
       include NaranyaEcm::Rest::Persistence
 
       extend NaranyaEcm::Rest::FinderMethods
-      
+
       alias_method_chain :initialize, :defaults
 
-      if NaranyaEcm.options[:extra_attributes] && (extra_fields = NaranyaEcm.options[:extra_attributes][self.name.demodulize.underscore])
+      if NContent::SDK.config.extra_attributes.present? and
+      extra_fields = NContent::SDK.config.extra_attributes[self.name.demodulize.underscore]
+
         extra_fields.each do |name, type|
-          
+
           field_options = {}
-          
+
           field_options[:type] = case type
           when 'boolean'
             NaranyaEcm::Rest::Model::BOOLEAN
@@ -88,12 +90,14 @@ module NaranyaEcm::Rest
     end
 
     def initialize_with_defaults(*args)
+      init_internals
+
       initialize_without_defaults(*args)
       # inicializar con los valores default los campos que esten nulos y tengan un default definido:
       self.class.fields.values
         .select { |f| instance_variable_get("@#{f[:name]}".to_sym).nil? && f[:default] }
         .each { |f| instance_variable_set("@#{f[:name]}".to_sym, f[:default].call) }
-      
+
     end
 
     def method_missing(method, *args, &block)
@@ -108,10 +112,42 @@ module NaranyaEcm::Rest
     end
 
     def attributes
-      HashWithIndifferentAccess[
-        self.class.fields.values
-          .map { |attr_data| [attr_data[:name], self.send(attr_data[:name].to_sym)] }
-      ]
+      self.class.fields.values.inject('id' => self.id) do |hsh, attr_data|
+        hsh[attr_data[:name].to_s] = self.public_send attr_data[:name]
+        hsh
+      end.with_indifferent_access
+    end
+
+    # Returns an <tt>#inspect</tt>-like string for the value of the
+    # attribute +attr_name+. String attributes are truncated upto 50
+    # characters, Date and Time attributes are returned in the
+    # <tt>:db</tt> format, Array attributes are truncated upto 10 values.
+    # Other attributes return the value of <tt>#inspect</tt> without
+    # modification.
+    #
+    #   person = Person.create!(name: 'David Heinemeier Hansson ' * 3)
+    #
+    #   person.attribute_for_inspect(:name)
+    #   # => "\"David Heinemeier Hansson David Heinemeier Hansson ...\""
+    #
+    #   person.attribute_for_inspect(:created_at)
+    #   # => "\"2012-10-22 00:15:07\""
+    #
+    #   person.attribute_for_inspect(:tag_ids)
+    #   # => "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...]"
+    def attribute_for_inspect(attr_name)
+      value = self.public_send(attr_name)
+
+      if value.is_a?(String) && value.length > 50
+        "#{value[0, 50]}...".inspect
+      elsif value.is_a?(Date) || value.is_a?(Time)
+        %("#{value.to_s(:db)}")
+      elsif value.is_a?(Array) && value.size > 10
+        inspected = value.first(10).inspect
+        %(#{inspected[0...-1]}, ...])
+      else
+        value.inspect
+      end
     end
 
     def associations
@@ -131,12 +167,19 @@ module NaranyaEcm::Rest
       "#{self.class.path}/#{self.id}"
     end
 
-    protected
+    # Returns the contents of the record as a nicely formatted string.
+    def inspect
+      # We check defined?(@attributes) not to issue warnings if the object is
+      # allocated but not initialized.
+      inspection = (['id'] + self.class.fields.keys.sort).map { |name|
+        value = attribute_for_inspect(name)
+        "#{name}: #{value}" unless value == 'nil'
+      }.compact.join(", ")
 
-      def off_band_changes
-        @off_band_changes ||= {}.with_indifferent_access
-      end
+      inspection = "not initialized" if inspection.blank?
 
+      "#<#{self.class} #{inspection}>"
+    end
 
     module ClassMethods
 
@@ -157,14 +200,14 @@ module NaranyaEcm::Rest
       end
 
       def field(name, options = {})
-        
+
         if options[:localize]
           lookup_alias_name = name
           name = "#{name}_translations".to_sym
         end
 
         fields[name] = {name: name}.merge(options).with_indifferent_access
-        
+
         attr_accessor name
         define_attribute_method name
 
@@ -201,7 +244,7 @@ module NaranyaEcm::Rest
       end
 
       def where(given_conditions={})
-        Relation.new self, given_conditions.with_indifferent_access 
+        Relation.new self, given_conditions.with_indifferent_access
       end
 
       delegate :first, :last, to: :all
@@ -209,7 +252,32 @@ module NaranyaEcm::Rest
       def all
         where()
       end
-      
+
+    end
+
+    # Returns +true+ if the resource is read only.
+    def readonly?
+      @readonly
     end
+
+    # Marks this record as read only.
+    def readonly!
+      @readonly = true
+    end
+
+    protected
+
+      def off_band_changes
+        @off_band_changes ||= {}.with_indifferent_access
+      end
+
+    private
+
+      def init_internals
+        @readonly                 = false
+        @destroyed                = false
+        @new_resource             = true
+      end
+
   end
-end
+end

data/lib/naranya_ecm/rest/persistence.rb

@@ -1,9 +1,67 @@
 module NaranyaEcm::Rest
 
   module Persistence
-
     extend ActiveSupport::Concern
 
+    class ReadOnlyResource < StandardError
+    end
+
+    class ResourceNotSaved < StandardError
+    end
+
+    class ResourceNotDestroyed < StandardError
+    end
+
+    module ClassMethods
+
+      # Updates an object (or multiple objects) and saves it to the server, if
+      # validations pass.
+      #
+      # The resulting object is returned whether the object was saved
+      # successfully to the server or not.
+      #
+      # ==== Parameters
+      #
+      # * +id+ - This should be the id or an array of ids to be updated.
+      # * +attributes+ - This should be a hash of attributes or an array of hashes.
+      #
+      # ==== Examples
+      #
+      #   # Updates one resource
+      #   Person.update(15, user_name: 'Samuel', group: 'expert')
+      #
+      #   # Updates multiple resources
+      #   people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy" } }
+      #   Person.update(people.keys, people.values)
+      def update(id, attributes)
+        if id.is_a?(Array)
+          id.map.with_index { |one_id, idx| update(one_id, attributes[idx]) }
+        else
+          object = find(id)
+          object.update(attributes)
+          object
+        end
+      end
+
+      def create(attributes={})
+        object_to_create = self.new attributes
+        object_to_create.save
+        object_to_create
+      end
+
+      def create!(attributes={})
+        created_object = create(attributes)
+        raise "ValidationError" unless created_object.persisted?
+        created_object
+      end
+
+      def delete(id, options={})
+        response = NContent::SDK::RESTClient.delete("#{self.path}/#{id}.json")
+        true
+      end
+
+    end
+
     included do
       define_model_callbacks :validation, :create, :update, :save, :destroy
     end
@@ -13,18 +71,98 @@ module NaranyaEcm::Rest
       self.update
     end
 
-    def save
+    # Returns true if this object hasn't been saved yet -- that is, a resource
+    # for the object doesn't exist at the server yet; otherwise, returns false.
+    def new_resource?
+      @new_resource
+    end
+
+    alias_method :new?, :new_resource?
+    alias_method :new_record?, :new_resource?
+
+    # Returns true if this object has been destroyed, otherwise returns false.
+    def destroyed?
+      @destroyed
+    end
+
+    # Returns true if the resource is persisted, i.e. it's not a new resource
+    # and it was not destroyed, otherwise returns false.
+    def persisted?
+      !(new_resource? || destroyed?)
+    end
+
+    # Saves the resource at the server.
+    #
+    # If the model is new a resource gets created at the server, otherwise
+    # the existing resource gets updated.
+    #
+    # By default, save always run validations. If any of them fail the action
+    # is cancelled and +save+ returns +false+. However, if you supply
+    # validate: false, validations are bypassed altogether. See
+    # ActiveModel::Validations for more information.
+    #
+    # There's a series of callbacks associated with +save+. If any of the
+    # <tt>before_*</tt> callbacks return +false+ the action is cancelled and
+    # +save+ returns +false+. See ActiveModel::Callbacks for further
+    # details.
+    #
+    # Attributes marked as readonly are silently ignored if the resource is
+    # being updated.
+    def save(*)
       run_callbacks :save do
         @previously_changed = changes
-        result = self.new_resource? ? self.create : self.update
+        result = create_or_update
         @changed_attributes.clear
         result
       end
     end
 
+    # Saves the model.
+    #
+    # If the model is new a resource gets created at the server, otherwise
+    # the existing resource gets updated.
+    #
+    # With <tt>save!</tt> validations always run. If any of them fail
+    # ActiveModel::resourceInvalid gets raised. See ActiveModel::Validations
+    # for more information.
+    #
+    # There's a series of callbacks associated with <tt>save!</tt>. If any of
+    # the <tt>before_*</tt> callbacks return +false+ the action is cancelled
+    # and <tt>save!</tt> raises ActiveModel::resourceNotSaved. See
+    # ActiveModel::Callbacks for further details.
+    #
+    # Attributes marked as readonly are silently ignored if the resource is
+    # being updated.
+    def save!(*)
+      create_or_update || raise(resourceNotSaved.new(nil, self))
+    end
+
+    # Deletes the resource at the server and freezes this instance to
+    # reflect that no changes should be made (since they can't be
+    # persisted). Returns the frozen instance.
+    #
+    # The row is simply removed with an SQL +DELETE+ statement on the
+    # resource's primary key, and no callbacks are executed.
+    #
+    # To enforce the object's +before_destroy+ and +after_destroy+
+    # callbacks or any <tt>:dependent</tt> association
+    # options, use <tt>#destroy</tt>.
+    def delete
+      self.class.delete(id) if persisted?
+      @destroyed = true
+      freeze
+    end
+
+    # Deletes the resource at the server and freezes this instance to reflect
+    # that no changes should be made (since they can't be persisted).
+    #
+    # There's a series of callbacks associated with <tt>destroy</tt>. If
+    # the <tt>before_destroy</tt> callback return +false+ the action is cancelled
+    # and <tt>destroy</tt> returns +false+. See
+    # Activeresource::Callbacks for further details.
     def destroy
       run_callbacks :destroy do
-        #raise ReadOnlyRecord if readonly?
+        #raise ReadOnlyresource if readonly?
         #destroy_associations
         self.class.delete(self.id) if persisted?
         @destroyed = true
@@ -32,14 +170,74 @@ module NaranyaEcm::Rest
       end
     end
 
-    def new_resource?; self.id.nil?; end
-    alias_method :new?, :new_resource?
-    alias_method :new_record?, :new_resource?
+    # Deletes the resource at the server and freezes this instance to reflect
+    # that no changes should be made (since they can't be persisted).
+    #
+    # There's a series of callbacks associated with <tt>destroy!</tt>. If
+    # the <tt>before_destroy</tt> callback return +false+ the action is cancelled
+    # and <tt>destroy!</tt> raises Activeresource::resourceNotDestroyed. See
+    # Activeresource::Callbacks for further details.
+    def destroy!
+      destroy || raise(ResourceNotDestroyed, self)
+    end
+
+    # Updates a single attribute and saves the resource.
+    # This is especially useful for boolean flags on existing resources.
+    # Also note that
+    #
+    # * Validation is skipped.
+    # * Callbacks are invoked.
+    # * updated_at/updated_on attribute is updated if that attribute is available.
+    # * Updates all the attributes that are dirty in this object.
+    #
+    # This method raises an +Activeresource::ActiveresourceError+  if the
+    # attribute is marked as readonly.
+    #
+    # See also +update_column+.
+    def update_attribute(name, value)
+      name = name.to_s
+      #verify_readonly_attribute(name)
+      send("#{name}=", value)
+      save(validate: false)
+    end
+
+    # Updates the attributes of the model from the passed-in hash and saves the
+    # resource, all wrapped in a transaction. If the object is invalid, the
+    # saving will fail and false will be returned.
+    def update(attributes)
+      assign_attributes(attributes)
+      save
+    end
+
+    def assign_attributes(given_attributes)
+      given_attributes.each do |key, val|
+        self.public_send "#{key}=", val
+      end
+    end
+
+    alias update_attributes update
 
-    def persisted?; !new_resource? || !self.changed?; end
+    # Updates its receiver just like +update+ but calls <tt>save!</tt> instead
+    # of +save+, so an exception is raised if the resource is invalid.
+    def update!(attributes)
+      # The following transaction covers any possible server side-effects of the
+      # attributes assignment. For example, setting the IDs of a child collection.
+      with_transaction_returning_status do
+        assign_attributes(attributes)
+        save!
+      end
+    end
+
+    alias update_attributes! update!
 
     protected
 
+      def create_or_update
+        raise ReadOnlyResource, "#{self.class} is marked as readonly" if readonly?
+        result = new_resource? ? _create_resource : _update_resource
+        result != false
+      end
+
       def load_server_errors(server_error_hash)
         server_error_hash = server_error_hash.with_indifferent_access
         if server_error_hash.present? && server_error_hash.has_key?(:errors) && server_error_hash[:errors].present?
@@ -54,10 +252,10 @@ module NaranyaEcm::Rest
       end
 
       def reload
-        format = NaranyaEcm.options[:format] || 'json'
-        response = Client.get "#{path}.#{format}"
-        
-        load(response.to_hash)
+        response = NContent::SDK::RESTClient.get "#{path}.json"
+
+        load(response.body)
+        @new_resource = false
         true
       end
 
@@ -70,24 +268,31 @@ module NaranyaEcm::Rest
         }
       end
 
-      def create
+      def _create_resource
         run_callbacks :create do
 
-          format = NaranyaEcm.options[:format] || 'json'
-          create_path = "#{self.class.path}.#{format}"
+          create_path = "#{self.class.path}.json"
 
           begin
-            response = Client.post create_path, persist_request_options(self.attributes)
-            self.load(response.to_hash)
+
+            response = NContent::SDK::RESTClient.post create_path do |req|
+              req.headers[:content_type] = 'application/json'
+              req.body = ActiveSupport::JSON.encode(
+                self.class.name.demodulize.underscore => attributes
+              )
+            end
+
+            self.load(response.body)
+            @new_resource = false
             true
           rescue UnprocessableEntity => e
-            self.load_server_errors(e.response.to_hash)
+            self.load_server_errors(e.response.body)
             false
           end
         end
       end
 
-      def update
+      def _update_resource
         run_callbacks :update do
 
           unless @is_touch
@@ -101,43 +306,26 @@ module NaranyaEcm::Rest
 
           attributes_to_save.merge! off_band_changes
 
-          format = NaranyaEcm.options[:format] || 'json'
-          update_path = "#{self.path}.#{format}"
+          update_path = "#{self.path}.json"
 
           begin
-            response = Client.put update_path, persist_request_options(attributes_to_save)
+            response = NContent::SDK::RESTClient.put update_path do |req|
+              req.headers[:content_type] = 'application/json'
+              req.body = ActiveSupport::JSON.encode(
+                self.class.name.demodulize.underscore => attributes_to_save
+              )
+            end
+
             self.reload!
             off_band_changes.clear if off_band_changes.present?
             true
           rescue UnprocessableEntity
-            self.load_server_errors(response.to_hash)
+            self.load_server_errors(response.body)
             false
           end
         end
       end
 
-
-    module ClassMethods
-
-      def create(attributes={})
-        object_to_create = self.new attributes
-        object_to_create.save
-        object_to_create
-      end
-
-      def create!(attributes={})
-        created_object = create(attributes)
-        raise "ValidationError" unless created_object.persisted?
-        created_object
-      end
-
-      def delete(id, options={})
-        response = Client.delete("#{self.path}/#{id}.json")
-        true
-      end
-
-    end
-
   end
 
-end
+end