scrivito_sdk 0.12.0

data/lib/generators/cms/migration/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Creates a new CMS migration.
+
+Example:
+    rails generate cms:migration CreateExample
+    rails generate cms:migration create_example
+
+    This will create:
+        cms/migrate/[timestamp]_create_example.rb

data/lib/generators/cms/migration/migration_generator.rb

@@ -0,0 +1,21 @@
+module Cms
+  class MigrationGenerator < ::Rails::Generators::NamedBase
+    include ::Rails::Generators::Migration
+
+    source_root File.expand_path('../templates', __FILE__)
+
+    class_option :path,
+      type: :string,
+      default: 'cms/migrate',
+      desc: 'Relative path to Rails.root where to place the migration file. Defaults to "cms/migrate".',
+      banner: 'PATH'
+
+    def self.next_migration_number(dirname)
+      Time.now.utc.strftime('%Y%m%d%H%M%S')
+    end
+
+    def create_migration_file
+      migration_template('migration.erb', "#{options[:path]}/#{file_name}.rb")
+    end
+  end
+end

data/lib/generators/cms/migration/templates/migration.erb

@@ -0,0 +1,10 @@
+class <%= class_name %> < ::Scrivito::Migration
+  def up
+    # get_obj_class('Test')
+    # create_obj_class(name: 'Test', type: :publication, attributes: [])
+    # update_obj_class('Test', title: 'Test Title')
+    # add_attribute_to('Test', { name: 'test', type: 'string' })
+    # update_attribute_for('Test', 'test', { title: 'New Title' })
+    # delete_attribute_from('Test', 'test')
+  end
+end

data/lib/obj.rb

@@ -0,0 +1,3 @@
+# empty implementation for Obj
+# only unsed in case the app does not define Obj itself
+::Obj = Class.new(Scrivito::BasicObj)

data/lib/scrivito/access_denied.rb

@@ -0,0 +1,6 @@
+module Scrivito
+
+  class AccessDenied < StandardError
+  end
+
+end

data/lib/scrivito/attribute_content.rb

@@ -0,0 +1,194 @@
+module Scrivito
+
+module AttributeContent
+  extend ActiveSupport::Concern
+
+  def respond_to?(method_id, include_private=false)
+    if has_attribute?(method_id)
+      true
+    else
+      super
+    end
+  end
+
+  def method_missing(method_name, *args)
+    if has_attribute?(method_name)
+      read_attribute(method_name.to_s)
+    else
+      super
+    end
+  end
+
+  def referenced_widgets
+    data_from_cms.all_custom_attributes.
+      select { |attr| type_of_attribute(attr) == "widget" }.
+      map { |attr| read_attribute(attr) }.
+      flatten
+  end
+
+  def contained_widgets
+    referenced = referenced_widgets
+    referenced + referenced.map { |w| w.contained_widgets }.flatten
+  end
+
+  def read_attribute(attribute_name)
+    @attribute_cache.fetch(attribute_name) do
+      (raw_value, attribute_type) = data_from_cms.value_and_type_of(attribute_name)
+      @attribute_cache[attribute_name] =
+        prepare_attribute_value(raw_value, attribute_type, attribute_name)
+    end
+  end
+
+  def has_attribute?(name)
+    data_from_cms.has_custom_attribute?(name.to_s)
+  end
+
+  # @return [String]
+  def type_of_attribute(field_name)
+    data_from_cms.type_of(field_name.to_s)
+  end
+
+  # Returns the value of an internal or external attribute specified by its name.
+  # Passing an invalid key will not raise an error, but return +nil+.
+  # @api public
+  def [](key)
+    key = key.to_s
+    has_attribute?(key) ? read_attribute(key) : nil
+  end
+
+  # Hook method to control which widget classes should be available for this page.
+  # Override it to allow only certain classes or none.
+  # Must return either +NilClass+, or +Array+.
+  #
+  # If +nil+ is returned (default), then all widget classes will be available for this page.
+  #
+  # If +Array+ is returned, then it should include desired class names.
+  # Each class name must be either a +String+ or a +Symbol+.
+  # Only this class names will be available for this page.
+  # Order of the class names will be preserved.
+  #
+  # @param [String] field_name Name of the widget field.
+  # @return [nil, Array<Symbol, String>]
+  # @api public
+  def valid_widget_classes_for(field_name)
+  end
+
+  def modification_for_attribute(attribute_name, revision=Workspace.current.base_revision)
+    if new?(revision)
+      Modification::NEW
+    elsif deleted?(revision)
+      Modification::DELETED
+    else
+      cms_data_in_revision = cms_data_for_revision(revision)
+
+      if cms_data_in_revision
+        other_value = cms_data_in_revision.unchecked_value_of(attribute_name.to_s)
+        if data_from_cms.unchecked_value_of(attribute_name.to_s) == other_value
+          Modification::UNMODIFIED
+        else
+          Modification::EDITED
+        end
+      else # I am deleted in both revisions!
+        Modification::UNMODIFIED
+      end
+    end
+  end
+
+  def update_data(data)
+    self.data_from_cms = data
+    @attribute_cache = {}
+  end
+
+  private
+
+  attr_writer :data_from_cms
+
+  def data_from_cms
+    if @data_from_cms.respond_to?(:call)
+      @data_from_cms = @data_from_cms.call
+    else
+      @data_from_cms
+    end
+  end
+
+  def prepare_attribute_value(attribute_value, attribute_type, attribute_name)
+    case attribute_type
+    when "html"
+      StringTagging.tag_as_html(attribute_value)
+    when "date"
+      DateAttribute.parse(attribute_value) if attribute_value
+    when "linklist"
+      build_links(attribute_value)
+    when "reference"
+      BasicObj.find([attribute_value]).first
+    when "referencelist"
+      BasicObj.find(attribute_value).compact
+    when "widget"
+      build_widgets(attribute_value, attribute_name)
+    else
+      attribute_value
+    end
+  end
+
+  def build_links(link_definitions)
+    if link_definitions.present?
+      link_definitions = link_definitions.map(&:with_indifferent_access)
+
+      object_ids = link_definitions.map { |link_data| link_data[:destination] }.compact.uniq
+      objects = object_ids.empty? ? [] : Obj.find(object_ids)
+      link_definitions.each_with_object([]) do |link_data, links|
+        obj = objects.detect { |o| o && o.id == link_data[:destination] }
+        link = Link.new(link_data.merge(obj: obj))
+        links << link if link.resolved?
+      end
+    else
+      []
+    end
+  end
+
+  def build_widgets(widget_data, attribute_name)
+    widget_data.map do |widget_id|
+      widget = widget_from_pool(widget_id)
+
+      unless widget
+        raise ScrivitoError, "Widget with ID #{widget_id} not found!"
+      end
+
+      widget.container = self
+      widget.container_field_name = attribute_name
+
+      widget
+    end
+  end
+
+  module ClassMethods
+    # Instantiate an Obj or Widget instance from obj_data.
+    # If a subclass of Obj or Widget with the same name as the property +_obj_class+ exists,
+    # the instantiated Obj or Widget will be an instance of that subclass.
+    def instantiate(obj_data)
+      obj_class = obj_data.value_of('_obj_class')
+
+      instance = type_computer.compute_type(obj_class).allocate
+      instance.update_data(obj_data)
+
+      instance
+    end
+
+    def with_default_obj_class(attributes)
+      return attributes if attributes[:_obj_class] || attributes["_obj_class"]
+      return attributes if type_computer.special_class?(self)
+      attributes.merge("_obj_class" => self.to_s)
+    end
+
+    def descendants
+      type_computer = TypeComputer.new(self, nil)
+      CmsRestApi.get("workspaces/#{Workspace.current.id}/obj_classes")['results']
+          .map { |obj_class_spec| obj_class_spec['name'] }
+          .sort
+          .map { |obj_class_name| type_computer.compute_type(obj_class_name) }
+          .compact
+    end
+  end
+end
+
+end

data/lib/scrivito/backend_error.rb

@@ -0,0 +1,4 @@
+module Scrivito
+  class BackendError < Scrivito::CommunicationError
+  end
+end

data/lib/scrivito/basic_obj.rb

@@ -0,0 +1,840 @@
+require 'json'
+require 'ostruct'
+require 'active_model/naming'
+
+module Scrivito
+  # The CMS file class
+  # @api public
+  class BasicObj
+    extend ActiveModel::Naming
+
+    include AttributeContent
+    include ModelIdentity
+
+    def self.type_computer
+      @_type_computer ||= TypeComputer.new(Scrivito::BasicObj, ::Obj)
+    end
+
+    def self.reset_type_computer!
+      @_type_computer = nil
+    end
+
+    # Create a new {BasicObj Obj} in the cms
+    #
+    # This allows you to set the different attributes types of an obj by
+    # providing a hash with the attributes names as key and the values you want
+    # to set as values
+    #
+    # @example Reference lists have to be provided as an Array of {BasicObj Objs}
+    #   Obj.create(:reference_list => [other_obj])
+    #
+    # @example Passing an {BasicObj Obj} allows you to set a reference
+    #   Obj.create(:reference => other_obj)
+    #
+    # @example you can upload files by passing a ruby File object
+    #   Obj.create(:blob => File.new("image.png"))
+    #
+    # @example Link list can be set as an Array of {Link Links}
+    #   Obj.create(:link_list => [
+    #     # external link
+    #     Link.new(:url => "http://www.example.com", :title => "Example"),
+    #     # internal link
+    #     Link.new(:obj => other_obj, :title => "Other Obj")
+    #   ])
+    #
+    # @example Dates attributes accept Time, Date and their subclasses (DateTime for example)
+    #   Obj.create(:date => Time.new)
+    #   Obj.create(:date => Date.now)
+    #
+    # @example String, text, html and enum can be set by passing a {String} value
+    #   Obj.create(:title => "My Title")
+    #
+    # @example Arrays of {String Strings} allow you to set multi enum fields
+    #   Obj.create(:tags => ["ruby", "rails"])
+    #
+    # @example Simply pass an Array of {BasicWidget Widgets} to change a widget field
+    #   # Add new widgets
+    #   Obj.create(:widgets => [Widget.new(_obj_class: 'TitleWidget', tite: 'My Title')])
+    #
+    #   # Changing a widget field
+    #   obj.update(:widgets => [obj.widgets.first])
+    #
+    #   # Clear a widget field
+    #   obj.update(:widgets => [])
+    #
+    # @api public
+    # @param [Hash] attributes
+    # @return [Obj] the newly created {BasicObj Obj}
+    def self.create(attributes)
+      attributes = with_default_obj_class(attributes)
+
+      widget_hash = CmsRestApi::WidgetExtractor.call(attributes)
+      converted_attributes = CmsRestApi::AttributeSerializer.convert(attributes)
+
+      converted_attributes['_widget_pool'] =
+        CmsRestApi::AttributeSerializer.generate_widget_pool_changes(widget_hash)
+
+      json = CmsRestApi.post(cms_rest_api_path, obj: converted_attributes)
+
+      obj = find(json['id'])
+
+      CmsRestApi::WidgetExtractor.notify_persisted_widgets(obj, widget_hash)
+
+      obj
+    end
+
+    # Create a new {BasicObj Obj} instance with the given values and attributes.
+    # Normally this method should not be used.
+    # Instead Objs should be loaded from the cms database.
+    def initialize(attributes = {})
+      update_data(ObjDataFromHash.new(attributes))
+    end
+
+    # @api public
+    def id
+      read_attribute('_id')
+    end
+
+    def revision=(revision)
+      raise "cannot change revision once set!" if @revision
+      @revision = revision
+    end
+
+    def revision
+      @revision or raise "revision not set!"
+    end
+
+    ### FINDERS ####################
+
+    # Find a {BasicObj Obj} by its id.
+    # If the paremeter is an Array containing ids, return a list of corresponding Objs.
+    # @param [String, Integer, Array<String, Integer>]id_or_list
+    # @return [Obj, Array<Obj>]
+    # @api public
+    def self.find(id_or_list)
+      find_filtering_deleted(id_or_list, false)
+    end
+
+    def self.find_by_id(id)
+      find_objs_by(:id, [id]).first.first
+    end
+
+    # Find a {BasicObj Obj} by its id.
+    # If the paremeter is an Array containing ids, return a list of corresponding Objs.
+    # The results include deleted objects as well.
+    # @param [String, Integer, Array<String, Integer>]id_or_list
+    # @return [Obj, Array<Obj>]
+    # @api public
+    def self.find_including_deleted(id_or_list)
+      find_filtering_deleted(id_or_list, true)
+    end
+
+    # Returns a {ObjSearchEnumerator} with the given initial subquery consisting of the four arguments.
+    #
+    # Note that +field+ and +value+ can also be arrays for searching several fields or searching for several values.
+    #
+    # {ObjSearchEnumerator}s can be chained using one of the chainable methods (e.g. {ObjSearchEnumerator#and} and {ObjSearchEnumerator#and_not}).
+    #
+    # @example Look for the first 10 Objs whose ObjClass is "Pressrelease" and whose title contains "quarterly":
+    #   Obj.where(:_obj_class, :equals, 'Pressrelease').and(:title, :contains, 'quarterly').take(10)
+    # @param [Symbol, String, Array<Symbol, String>] field See {ObjSearchEnumerator#and} for details
+    # @param [Symbol, String] operator See {ObjSearchEnumerator#and} for details
+    # @param [String, Array<String>] value See {ObjSearchEnumerator#and} for details
+    # @param [Hash] boost See {ObjSearchEnumerator#and} for details
+    # @return [ObjSearchEnumerator]
+    # @api public
+    def self.where(field, operator, value, boost = nil)
+      ObjSearchEnumerator.new(nil).and(field, operator, value, boost)
+    end
+
+    # Returns a {ObjSearchEnumerator} of all {BasicObj Obj}s.
+    # If invoked on a subclass of Obj, the result will be restricted to instances of that subclass.
+    # @return [ObjSearchEnumerator]
+    # @api public
+    def self.all
+      if superclass == Scrivito::BasicObj
+        search_for_all
+      else
+        find_all_by_obj_class(name)
+      end
+    end
+
+    # Returns a {ObjSearchEnumerator} of all Objs with the given +obj_class+.
+    # @param [String] obj_class Name of the ObjClass.
+    # @return [ObjSearchEnumerator]
+    # @api public
+    def self.find_all_by_obj_class(obj_class)
+      search_for_all.and(:_obj_class, :equals, obj_class)
+    end
+
+    # Find the {BasicObj Obj} with the given path.
+    # Returns +nil+ if no matching Obj exists.
+    # @param [String] path Path of the {BasicObj Obj}.
+    # @return [Obj]
+    # @api public
+    def self.find_by_path(path)
+      find_objs_by(:path, [path]).first.first
+    end
+
+    def self.find_many_by_paths(pathes)
+      find_objs_by(:path, pathes).map(&:first)
+    end
+
+    # Find an {BasicObj Obj} with the given name.
+    # If several Objs with the given name exist, an arbitrary one of these Objs is chosen and returned.
+    # If no Obj with the name exits, +nil+ is returned.
+    # @param [String] name Name of the {BasicObj Obj}.
+    # @return [Obj]
+    # @api public
+    def self.find_by_name(name)
+      where(:_name, :equals, name).batch_size(1).first
+    end
+
+    # Returns a {ObjSearchEnumerator} of all Objs with the given name.
+    # @param [String] name Name of the {BasicObj Obj}.
+    # @return [ObjSearchEnumerator]
+    # @api public
+    def self.find_all_by_name(name)
+      where(:_name, :equals, name)
+    end
+
+    # Returns the {BasicObj Obj} with the given permalink, or +nil+ if no matching Obj exists.
+    # @param [String] permalink The permalink of the {BasicObj Obj}.
+    # @return [Obj]
+    # @api public
+    def self.find_by_permalink(permalink)
+      find_objs_by(:permalink, [permalink]).first.first
+    end
+
+    # Returns the {BasicObj Obj} with the given permalink, or raise ResourceNotFound if no matching Obj exists.
+    # @param [String] permalink The permalink of the {BasicObj Obj}.
+    # @return [Obj]
+    # @api public
+    def self.find_by_permalink!(permalink)
+      find_by_permalink(permalink) or
+        raise ResourceNotFound, "Could not find Obj with permalink '#{permalink}'"
+    end
+
+    # accepts the name of an "obj_by" - view, a list of keys
+    # and an "include_deleted" flag
+    # returns a list of lists of Objs: a list of Objs for each given keys.
+    def self.find_objs_by(view, keys, include_deleted = false)
+      if include_deleted
+        finder_method_name = :find_obj_data_including_deleted_by
+      else
+        finder_method_name = :find_obj_data_by
+      end
+
+      revision = Workspace.current.revision
+      result = CmsBackend.instance.public_send(finder_method_name, revision, view, keys)
+
+      result.map do |list|
+        list.map do |obj_data|
+          obj = BasicObj.instantiate(obj_data)
+          obj.revision = revision
+
+          obj
+        end
+      end
+    end
+
+    # Hook method to control which page classes should be available for a page with given path.
+    # Override it to allow only certain classes or none.
+    # Must return either +NilClass+, or +Array+.
+    #
+    # Be aware that the given argument is a parent path.
+    # E.g. when creating a page with path +/products/shoes+ then the argument will be +/products+.
+    #
+    # If +NilClass+ is returned, then all possible classes will be available.
+    # By default +NilClass+ is returned.
+    #
+    # If +Array+ is returned, then it should include desired class names.
+    # Each class name must be either a +String+ or a +Symbol+.
+    # Only this class names will be available. Order of the class names will be preserved.
+    #
+    # @param [String] parent_path Path of the parent obj
+    # @return [NilClass, Array<Symbol, String>]
+    # @api public
+    def self.valid_page_classes_beneath(parent_path)
+    end
+
+    # Update the {BasicObj Obj} with the attributes provided.
+    #
+    # For an overview of which values you can set via this method see the
+    # documentation of {BasicObj.create Obj.create}.
+    #
+    # @api public
+    # @param [Hash] attributes
+    def update(attributes)
+      widget_hash = CmsRestApi::WidgetExtractor.call(attributes, self)
+      converted_attributes = CmsRestApi::AttributeSerializer.convert(attributes)
+
+      converted_attributes['_widget_pool'] =
+          CmsRestApi::AttributeSerializer.generate_widget_pool_changes(widget_hash)
+
+      widget_pool = converted_attributes['_widget_pool']
+      widget_gc = WidgetGarbageCollection.new(self, {self => attributes}.merge(widget_hash))
+      widget_gc.widgets_to_delete.each { |widget| widget_pool[widget.id] = nil }
+
+      CmsRestApi.put(cms_rest_api_path, obj: converted_attributes)
+
+      Workspace.reload
+
+      reload
+
+      CmsRestApi::WidgetExtractor.notify_persisted_widgets(self, widget_hash)
+
+      self
+    end
+
+    # Destroys the {BasicObj Obj} in the current {Workspace}
+    # @api public
+    def destroy
+      if children.any?
+        raise ClientError.new(I18n.t('scrivito.errors.models.basic_obj.has_children'), 412)
+      end
+
+      CmsRestApi.delete(cms_rest_api_path)
+
+      Workspace.reload
+    end
+
+    def to_param
+      id
+    end
+
+    # return the {BasicObj Obj} that is the parent of this Obj.
+    # returns +nil+ for the root Obj.
+    # @api public
+    def parent
+      if child_path?
+        BasicObj.find_by_path(parent_path)
+      end
+    end
+
+    # Returns an Array of all the ancestor objects, starting at the root and ending at this object's parent.
+    # @return [Array<Obj>]
+    # @api public
+    def ancestors
+      return [] unless child_path?
+
+      ancestor_paths = parent_path.scan(/\/[^\/]+/).inject([""]) do |list, component|
+        list << list.last + component
+      end
+      ancestor_paths[0] = "/"
+      BasicObj.find_many_by_paths(ancestor_paths)
+    end
+
+    # return a list of all child {BasicObj Obj}s.
+    # @return [Array<Obj>]
+    # @api public
+    def children
+      return [] unless path
+
+      self.class.find_objs_by(:ppath, [path]).first
+    end
+
+    ### ATTRIBUTES #################
+
+    # returns the {BasicObj Obj}'s path as a String.
+    # @api public
+    def path
+      read_attribute('_path')
+    end
+
+    # returns the {BasicObj Obj}'s name, i.e. the last component of the path.
+    # @api public
+    def name
+      if child_path?
+        path.match(/[^\/]+$/)[0]
+      else
+        ""
+      end
+    end
+
+    # Returns the root {BasicObj Obj}, i.e. the Obj with the path "/"
+    # @return [Obj]
+    # @api public
+    def self.root
+      BasicObj.find_by_path("/") or raise ResourceNotFound,
+          "Obj.root not found: There is no Obj with path '/'."
+    end
+
+    # Returns the homepage obj. This can be overwritten in your application's +Obj+.
+    # Use {#homepage?} to check if an obj is the homepage.
+    # @return [Obj]
+    # @api public
+    def self.homepage
+      root
+    end
+
+    # @api private
+    def self.generate_widget_pool_id
+      SecureRandom.hex(4)
+    end
+
+    # returns the obj's permalink.
+    # @api public
+    def permalink
+      read_attribute('_permalink')
+    end
+
+    # This method determines the controller that should be invoked when the +Obj+ is requested.
+    # By default a controller matching the Obj's obj_class will be used.
+    # If the controller does not exist, the CmsController will be used as a fallback.
+    # Overwrite this method to force a different controller to be used.
+    # @return [String]
+    # @api public
+    def controller_name
+      obj_class_name
+    end
+
+    # This method determines the action that should be invoked when the +Obj+ is requested.
+    # The default action is 'index'.
+    # Overwrite this method to force a different action to be used.
+    # @return [String]
+    # @api public
+    def controller_action_name
+      "index"
+    end
+
+    # Returns true if the current obj is the {.homepage} obj.
+    # @api public
+    def homepage?
+      self == self.class.homepage
+    end
+
+    # This method is used to calculate a part of a URL of this Obj.
+    #
+    # The routing schema: <code><em><obj.id></em>/<em><obj.slug></em></code>
+    #
+    # The default is {http://apidock.com/rails/ActiveSupport/Inflector/parameterize parameterize}
+    # on +obj.title+.
+    #
+    # You can customize this part by overwriting {#slug}.
+    # @return [String]
+    # @api public
+    def slug
+      (title || '').parameterize
+    end
+
+    # This method determines the description that is shown in the changes list.
+    # It can be overriden by a custom value.
+    # @api public
+    def description_for_editor
+      slug.presence || path
+    end
+
+    # Returns the title of the content or the name.
+    # @return [String]
+    # @api public
+    def display_title
+      self.title || name
+    end
+
+    # @api public
+    def title
+      read_attribute('title')
+    end
+
+    # Returns true if image? or generic?
+    def binary?
+      [:image, :generic].include?(read_attribute('_obj_type').to_sym)
+    end
+
+    # Returns true if this object is the root object.
+    # @api public
+    def root?
+      path == "/"
+    end
+
+    # Returns a list of children excluding the binary? ones unless :all is specfied.
+    # This is mainly used for navigations.
+    # @return [Array<Obj>]
+    # @api public
+    def toclist(*args)
+      return [] if binary?
+      toclist = children
+      toclist = toclist.reject { |toc| toc.binary? } unless args.include?(:all)
+      toclist
+    end
+
+    # @param objs_to_be_sorted [Array<BasicObj>] unsorted list of Objs
+    # @param list [Array<BasicObj>] list of Objs that defines the order
+    # @return [Array<BasicObj>] a sorted list of Objs. Any objs present in +objs_to_be_sorted+ but not in +list+ are appended at the end, sorted by +Obj#id+
+    def self.sort_by_list(objs_to_be_sorted, list)
+      (list & objs_to_be_sorted) + (objs_to_be_sorted - list).sort_by(&:id)
+    end
+
+    # This should be a SET, because it's faster in this particular case.
+    OLD_INTERNAL_KEYS = Set.new(%w[
+      body
+      id
+      last_changed
+      name
+      obj_class_name
+      path
+      permalink
+      text_links
+      title
+    ])
+
+    # Returns the value of an internal or external attribute specified by its name.
+    # Passing an invalid key will not raise an error, but return +nil+.
+    # @api public
+    def [](key)
+      key = key.to_s
+      if OLD_INTERNAL_KEYS.include?(key)
+        send(key)
+      elsif key.start_with?('_') && OLD_INTERNAL_KEYS.include?(internal_key = key[1..-1])
+        # For backwards compatibility reasons
+        send(internal_key)
+      else
+        super
+      end
+    end
+
+    # Reloads the attributes of this object from the database.
+    # Notice that the ruby class of this Obj instance will NOT change,
+    # even if the obj_class in the database has changed.
+    # @api public
+    def reload
+      id = self.id.to_s
+
+      reload_data = Proc.new do
+        CmsBackend.instance.find_obj_data_by(Workspace.current.revision, :id, [id]).first.first
+      end
+
+      update_data(reload_data)
+    end
+
+    # @return [String]
+    # @api public
+    def obj_class_name
+      read_attribute('_obj_class')
+    end
+
+    def obj_class
+      raise ScrivitoError, "BasicObj#obj_class is no longer available"+
+        ", please use BasicObj#obj_class_name instead."
+    end
+
+    # @api public
+    def last_changed
+      read_attribute('_last_changed')
+    end
+
+    def new?(revision=Workspace.current.base_revision)
+      if read_attribute('_modification') != 'deleted'
+        cms_data_for_revision(revision).nil?
+      else
+        false
+      end
+    end
+
+    def deleted?(revision=Workspace.current.base_revision)
+      if read_attribute('_modification') == 'deleted'
+        cms_data_for_revision(revision).present?
+      end
+    end
+
+    def modification(revision=Workspace.current.base_revision)
+      obj_data_from_revision = cms_data_for_revision(revision)
+
+      if deleted?(revision)
+        Modification::DELETED
+      elsif new?(revision)
+        Modification::NEW
+      else # Edited
+        if obj_data_from_revision.present?
+          if data_from_cms == obj_data_from_revision
+            Modification::UNMODIFIED
+          else
+            Modification::EDITED
+          end
+        else
+          Modification::UNMODIFIED
+        end
+      end
+    end
+
+    def widget_data_for_revision(id, revision)
+      if revision_obj_data = cms_data_for_revision(revision)
+        revision_obj_data.value_of('_widget_pool')[id]
+      end
+    end
+
+    def in_revision(revision)
+      if obj_data = cms_data_for_revision(revision)
+        obj = Obj.instantiate(obj_data)
+        obj.revision = revision
+
+        obj
+      end
+    end
+
+    # For a binary Obj, the content_type is equal to the content_type of its body (i.e. its data).
+    # For non-binary Objs, a the default content_type is "text/html".
+    # Override this method in subclasses to define a different content_type.
+    # Note that only Objs with content_type "text/html"
+    # will be rendered with layout and templates by the DefaultCmsController.
+    # @return [String]
+    # @api public
+    def content_type
+      if binary?
+        body_content_type
+      else
+        "text/html"
+      end
+    end
+    alias mime_type content_type
+
+    # returns the extension (the part after the last dot) from the Obj's name.
+    # returns an empty string if no extension is present in the Obj's name.
+    # @return [String]
+    # @api public
+    def file_extension
+      File.extname(name)[1..-1] || ""
+    end
+
+    # Returns the body (main content) of the Obj for non-binary Objs.
+    # Returns +nil+ for binary Objs.
+    # @return [String]
+    # @api public
+    def body
+      if binary?
+        nil
+      else
+        StringTagging.tag_as_html(read_attribute('body'))
+      end
+    end
+
+    # for binary Objs body_length equals the file size
+    # for non-binary Objs body_length equals the number of characters in the body (main content)
+    # @api public
+    def body_length
+      if binary?
+        blob = find_blob
+        blob ? blob.length : 0
+      else
+        (body || "").length
+      end
+    end
+
+    # returns an URL to retrieve the Obj's body for binary Objs.
+    # returns +nil+ for non-binary Objs.
+    # @return [String]
+    # @api public
+    def body_data_url
+      if binary?
+        blob = find_blob
+        blob.url if blob
+      end
+    end
+
+    # returns the content type of the Obj's body for binary Objs.
+    # returns +nil+ for non-binary Objs.
+    # @return [String]
+    # @api public
+    def body_content_type
+      if binary?
+        blob = find_blob
+        if blob
+          blob.content_type
+        else
+          "application/octet-stream"
+        end
+      end
+    end
+
+    def inspect
+      "<#{self.class} id=\"#{id}\" path=\"#{path}\">"
+    end
+
+    def details_view_path
+      "#{obj_class_name.underscore}/details"
+    end
+
+    def widget_from_pool(widget_id)
+      widget_data = widget_data_from_pool(widget_id)
+      instantiate_widget(widget_id, widget_data) if widget_data
+    end
+
+    def copy_widget_from(src_obj_id, src_widget_id)
+      raise "cannot copy widget, since workspace is not modifiable" if Workspace.current.published?
+
+      src_obj_content = CmsRestApi.get(cms_rest_api_path(src_obj_id))
+      widget_content = src_obj_content["_widget_pool"]["#{src_widget_id}"]
+
+      raise "cannot copy widget, since widget does not exist" unless widget_content
+
+      src_widget = BasicObj.find(src_obj_id).widget_from_pool(src_widget_id)
+      widget_content.delete_if do |attribute_name, _|
+        src_widget.type_of_attribute(attribute_name) == "widget"
+      end
+      widget_pool_id = BasicObj.generate_widget_pool_id
+
+      CmsRestApi.put(cms_rest_api_path, obj: {_widget_pool: {widget_pool_id => widget_content}})
+
+      widget_pool_id
+    end
+
+    # for internal testing purposes only
+    def blob_id
+      find_blob.try(:id)
+    end
+
+    # Reverts changes of this object.
+    # After calling this method it's as if this object has been never modified in the current working copy.
+    # This method does not work with +new+ or +deleted+ objects.
+    # This method also does also not work for the +published+ workspace or the +rtc+ working copy.
+    def revert
+      Workspace.current.assert_revertable
+
+      if binary?
+        raise "revert not supported for binary objs"
+      else
+        case modification
+        when Modification::UNMODIFIED
+          # don't do anything
+        when Modification::EDITED
+          previous_content = CmsRestApi.get(
+              "revisions/#{Workspace.current.base_revision_id}/objs/#{id}")
+          updated_content = previous_content.except('id', '_id')
+
+          added_widget_ids = read_widget_pool.keys - previous_content['_widget_pool'].keys
+          added_widget_ids.each do |added_widget_id|
+            updated_content['_widget_pool'][added_widget_id] = nil
+          end
+
+          CmsRestApi.put(cms_rest_api_path, obj: updated_content)
+
+          reload
+        else
+          raise ScrivitoError, "cannot revert changes, since obj is #{modification}."
+        end
+      end
+    end
+
+    def mark_resolved
+      CmsRestApi.put(cms_rest_api_path, obj: {_conflicts: nil})
+      reload
+    end
+
+    def container_and_field_name_for_widget(widget_id)
+      if field_name = field_name_in_data_for_widget(data_from_cms, widget_id)
+        return [self, field_name]
+      else
+        read_widget_pool.each do |parent_widget_id, widget_data|
+          if field_name = field_name_in_data_for_widget(widget_data, widget_id)
+            return [widget_from_pool(parent_widget_id), field_name]
+          end
+        end
+      end
+      [nil, nil]
+    end
+
+    def widget_data_from_pool(widget_id)
+      read_widget_pool[widget_id]
+    end
+
+    def has_conflict?
+      read_attribute('_conflicts') != nil
+    end
+
+    def all_widgets_from_pool
+      read_widget_pool.keys.map do |widget_id|
+        widget_from_pool(widget_id)
+      end
+    end
+
+    def generate_widget_pool_id
+      10.times do
+        id = self.class.generate_widget_pool_id
+
+        return id if widget_data_from_pool(id).nil?
+      end
+
+      raise ScrivitoError.new('Could not generate a new unused widget id')
+    end
+
+    private
+
+    def cms_data_for_revision(revision)
+      if revision
+        CmsBackend.instance.find_obj_data_by(revision, "id", [id]).first.first
+      end
+    end
+
+    def field_name_in_data_for_widget(data, widget_id)
+      data.all_custom_attributes.find do |attribute_name|
+        (value, type) = data.value_and_type_of(attribute_name)
+        type == "widget" && value.include?(widget_id)
+      end
+    end
+
+    def read_widget_pool
+      read_attribute('_widget_pool')
+    end
+
+    def instantiate_widget(widget_id, widget_data)
+      BasicWidget.instantiate(widget_data).tap do |widget|
+        widget.id = widget_id
+        widget.obj = self
+      end
+    end
+
+    def parent_path
+      raise "parent_path called for root" if root?
+      path.gsub(/\/[^\/]+$/, "").presence || "/"
+    end
+
+    def as_date(value)
+      DateAttribute.parse(value) unless value.nil?
+    end
+
+    def find_blob
+      blob_spec = read_attribute('blob')
+      Blob.find(blob_spec["id"]) if blob_spec
+    end
+
+    def cms_rest_api_path(obj_id = id)
+      "#{self.class.cms_rest_api_path}/#{obj_id}"
+    end
+
+    def child_path?
+      !path.nil? && !root?
+    end
+
+    class << self
+      def restore(obj_id)
+        Workspace.current.assert_revertable
+
+        base_revision_path = "revisions/#{Workspace.current.base_revision_id}/objs/#{obj_id}"
+        obj_attributes = CmsRestApi.get(base_revision_path).except('id').merge('_id' => obj_id)
+        CmsRestApi.post(cms_rest_api_path, obj: obj_attributes)
+      end
+
+      def cms_rest_api_path
+        "workspaces/#{Workspace.current.id}/objs"
+      end
+
+      private
+
+      def find_filtering_deleted(id_or_list, include_deleted)
+        case id_or_list
+        when Array
+          find_objs_by(:id, id_or_list, include_deleted).map(&:first).compact
+        else
+          obj = find_objs_by(:id, [id_or_list.to_s], include_deleted).first.first
+          obj or raise ResourceNotFound, "Could not find Obj with id #{id_or_list}"
+        end
+      end
+
+      def search_for_all
+        ObjSearchEnumerator.new(nil).batch_size(1000)
+      end
+    end
+  end
+
+end