scrivito_sdk 0.50.1 → 0.60.0.rc1

data/lib/scrivito/attribute_definition.rb

@@ -3,36 +3,42 @@ module Scrivito
 #
 # This class represents a definition of an attribute.
 #
-# @api private
+# @api public
 #
 class AttributeDefinition
   #
   # @!attribute [r] name
-  #   @api private
-  #   @return [Symbol] the name of the attribute.
+  #   @api public
+  #   @return [String] the name of the attribute.
   #
   # @!attribute [r] type
-  #   @api private
-  #   @return [Symbol] the type of the attribute.
+  #   @api public
+  #   @return [String] the type of the attribute.
   #
   attr_reader :name, :type
 
   def initialize(name, type, options = {})
-    @name, @type, @options = name, type, options
+    @name, @type, @options = name.to_s, type.to_s, options.with_indifferent_access
   end
 
   #
   # Allowed values for an attribute.
   #
-  # @api private
-  # @return [[String], nil] allowed values if type is +enum+ or +multienum+ or +nil+ otherwise.
-  #   If no values have been specified, then an empty array will be returned.
+  # @api public
+  # @return [Array<String>] allowed values if type is +enum+ or +multienum+ or an empty array
+  #   otherwise. If no values have been specified, then an empty array will be returned.
   #
   def values
-    if type == :enum || type == :multienum
+    if type == 'enum' || type == 'multienum'
       @options[:values] || []
+    else
+      []
     end
   end
+
+  def widgetlist?
+    type == 'widgetlist'
+  end
 end
 
 end

data/lib/scrivito/attribute_definition_collection.rb

@@ -3,11 +3,14 @@ module Scrivito
 #
 # This class represents a collection of attribute definitions.
 #
-# @api private
+# @api public
 #
 class AttributeDefinitionCollection
   include Enumerable
 
+  # Compatibility for Object#blank?
+  delegate :empty?, to: :attribute_definitions
+
   def initialize(attribute_definitions)
     @attribute_definitions = attribute_definitions
   end
@@ -15,7 +18,7 @@ class AttributeDefinitionCollection
   #
   # Iterates over the attribute definitions.
   #
-  # @api private
+  # @api public
   # @yieldparam [Scrivito:AttributeDefinition] attribute_definition
   #
   def each(&block)
@@ -25,12 +28,12 @@ class AttributeDefinitionCollection
   #
   # Find definition of an attribute.
   #
-  # @api private
+  # @api public
   # @param name [Symbol, String] the name of the attribute.
   # @return [Scrivito::AttributeDefinition, nil] attribute definition if found or +nil+ otherwise.
   #
   def [](name)
-    attribute_definitions[name.to_sym]
+    attribute_definitions[name.to_s]
   end
 
   private

data/lib/scrivito/attribute_definition_migrator.rb

@@ -30,9 +30,7 @@ class AttributeDefinitionMigrator
         with_padding do
           say %{[warning] Model "#{model_class}" has no corresponding ObjClass in published workspace.
   Ignore this message if it is an abstract class and should not have an ObjClass by design.
-  Otherwise:
-      - Is there a pending migration which will create an ObjClass for "#{model_class}"? Please run and publish this migration.
-      - Or maybe "#{model_class}" is not used anymore and file #{relative_path} can be removed?
+  Or maybe "#{model_class}" is not used anymore and file #{relative_path} can be removed?
 }, :yellow
         end
         say_status :skipping, relative_path

data/lib/scrivito/attribute_deserializer.rb

@@ -0,0 +1,111 @@
+module Scrivito
+
+class AttributeDeserializer < Struct.new(:model, :workspace)
+  def deserialize(attribute_value, attribute_definition)
+    case attribute_definition.type
+    when 'binary'        then deserialize_binary_value(attribute_value)
+    when 'date'          then deserialize_date_value(attribute_value)
+    when 'enum'          then deserialize_enum_value(attribute_value, attribute_definition)
+    when 'html'          then deserialize_html_value(attribute_value)
+    when 'link'          then deserialize_link_value(attribute_value)
+    when 'linklist'      then deserialize_linklist_value(attribute_value)
+    when 'multienum'     then deserialize_multienum_value(attribute_value, attribute_definition)
+    when 'reference'     then deserialize_reference_value(attribute_value)
+    when 'referencelist' then deserialize_referencelist_value(attribute_value)
+    when 'widget'        then deserialize_legacy_widget_value(attribute_value, attribute_definition)
+    when 'widgetlist'    then deserialize_widgetlist_value(attribute_value, attribute_definition)
+    else attribute_value
+    end
+  end
+
+  private
+
+  def deserialize_binary_value(attribute_value)
+    if attribute_value && (id = attribute_value['id'])
+      Binary.new(id, workspace.published?)
+    end
+  end
+
+  def deserialize_date_value(attribute_value)
+    DateAttribute.parse(attribute_value) if attribute_value
+  end
+
+  def deserialize_enum_value(attribute_value, attribute_definition)
+    attribute_value if attribute_definition.values.include?(attribute_value)
+  end
+
+  def deserialize_html_value(attribute_value)
+    StringTagging.tag_as_html(attribute_value)
+  end
+
+  def deserialize_link_value(attribute_value)
+    return unless attribute_value
+    if attribute_value['destination']
+      deserialize_internal_link(attribute_value)
+    else
+      deserialize_external_link(attribute_value)
+    end
+  end
+
+  def deserialize_linklist_value(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? ? [] : workspace.objs.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 deserialize_multienum_value(attribute_value, attribute_definition)
+    attribute_value & attribute_definition.values
+  end
+
+  def deserialize_reference_value(attribute_value)
+    workspace.objs.find([attribute_value]).first
+  end
+
+  def deserialize_referencelist_value(attribute_value)
+    workspace.objs.find(attribute_value).compact
+  end
+
+  def deserialize_internal_link(attribute_value)
+    Link.new(attribute_value.slice('title', 'query', 'fragment', 'target').symbolize_keys
+      .merge(obj: workspace.objs.find(attribute_value['destination'])))
+  rescue ResourceNotFound
+  end
+
+  def deserialize_external_link(attribute_value)
+    Link.new(attribute_value.slice('url', 'title', 'target').symbolize_keys)
+  end
+
+  def deserialize_legacy_widget_value(widget_ids, attribute_definition)
+    if workspace.uses_obj_classes
+      deserialize_widgetlist_value(widget_ids, attribute_definition)
+    end
+  end
+
+  def deserialize_widgetlist_value(widget_ids, attribute_definition)
+    if widget_ids
+      widget_ids.map { |widget_id| deserialize_widget_value(widget_id, attribute_definition) }
+    else
+      []
+    end
+  end
+
+  def deserialize_widget_value(widget_id, attribute_definition)
+    model.widget_from_pool(widget_id).tap do |widget|
+      raise ScrivitoError, "Widget with ID #{widget_id} not found!" unless widget
+      widget.container = model
+      widget.container_attribute_name = attribute_definition.name
+    end
+  end
+end
+
+end

data/lib/scrivito/attribute_serializer.rb

@@ -0,0 +1,189 @@
+module Scrivito
+
+class AttributeSerializer
+  def serialize(attributes, attribute_definitions)
+    return attributes if attributes.blank?
+    serialized_attributes = attributes.map do |attribute_name, attribute_value|
+      serialize_attribute(attribute_name, attribute_value, attribute_definitions)
+    end
+    Hash[serialized_attributes]
+  end
+
+  private
+
+  def serialize_attribute(attribute_name, attribute_value, attribute_definitions)
+    attribute_name = attribute_name.to_s
+    if attribute_name.starts_with?('_')
+      serialize_system_attribute(attribute_name, attribute_value)
+    else
+      attribute_definition = attribute_definitions[attribute_name]
+      serialize_custom_attribute(attribute_name, attribute_value, attribute_definition)
+    end
+  end
+
+  def serialize_system_attribute(attribute_name, attribute_value)
+    if %w[
+      _id
+      _obj_class
+      _path
+      _permalink
+    ].include?(attribute_name)
+      [attribute_name, attribute_value.to_s]
+    else
+      raise ScrivitoError, "Unknown attribute '#{attribute_name}'"
+    end
+  end
+
+  def serialize_custom_attribute(attribute_name, attribute_value, attribute_definition)
+    raise ScrivitoError, "Unknown attribute '#{attribute_name}'" unless attribute_definition
+    attribute_value = case attribute_type = attribute_definition.type
+      when 'binary'        then serialize_binary_value(attribute_value, attribute_definition)
+      when 'date'          then serialize_date_value(attribute_value, attribute_definition)
+      when 'enum'          then serialize_enum_value(attribute_value, attribute_definition)
+      when 'html'          then serialize_html_value(attribute_value)
+      when 'link'          then serialize_link_value(attribute_value, attribute_definition)
+      when 'linklist'      then serialize_linklist_value(attribute_value, attribute_definition)
+      when 'multienum'     then serialize_multienum_value(attribute_value, attribute_definition)
+      when 'reference'     then serialize_reference_value(attribute_value)
+      when 'referencelist' then serialize_referencelist_value(attribute_value, attribute_definition)
+      when 'string'        then serialize_string_value(attribute_value)
+      when 'stringlist'    then serialize_stringlist_value(attribute_value, attribute_definition)
+      when 'widget'        then serialize_widget_value(attribute_value, attribute_definition)
+      when 'widgetlist'    then serialize_widgetlist_value(attribute_value, attribute_definition)
+      end
+    [attribute_name, [serialize_attribute_type(attribute_type), attribute_value]]
+  end
+
+  def serialize_attribute_type(attribute_type)
+    case attribute_type
+    when 'enum'      then 'string'
+    when 'multienum' then 'stringlist'
+    else attribute_type
+    end
+  end
+
+  def serialize_binary_value(attribute_value, attribute_definition)
+    return unless attribute_value
+    case attribute_value
+    when File           then CmsRestApi.upload_file(attribute_value)
+    when UploadedBinary then attribute_value.params
+    else
+      raise_validation_error(attribute_definition.name,
+        'an instance of File, Scrivito::UploadedBinary or nil', attribute_value)
+    end
+  end
+
+  def serialize_date_value(attribute_value, attribute_definition)
+    return unless attribute_value
+    attribute_value = DateAttribute.serialize(attribute_value)
+    unless attribute_value
+      raise_validation_error(attribute_definition.name, 'an instance of Date or Time',
+        attribute_value)
+    end
+    attribute_value
+  end
+
+  def serialize_enum_value(attribute_value, attribute_definition)
+    return unless attribute_value
+    attribute_value = attribute_value.to_s
+    attribute_values = attribute_definition.values
+    if attribute_values.include?(attribute_value)
+      attribute_value
+    else
+      raise_validation_error(attribute_definition.name, format_array(attribute_values),
+        attribute_value)
+    end
+  end
+
+  def serialize_html_value(attribute_value)
+    attribute_value.to_s
+  end
+
+  def serialize_link_value(attribute_value, attribute_definition)
+    return unless attribute_value
+    if attribute_value.is_a?(Link)
+      attribute_value.to_cms_api_linklist_params
+    else
+      raise_validation_error(attribute_definition.name, 'an instance of Scrivito::Link',
+        attribute_value)
+    end
+  end
+
+  def serialize_linklist_value(attribute_value, attribute_definition)
+    if attribute_value.is_a?(Enumerable) && attribute_value.all? { |item| item.is_a?(Link) }
+      attribute_value.map(&:to_cms_api_linklist_params)
+    else
+      raise_validation_error(attribute_definition.name,
+        'Enumerable containing instances of Scrivito::Link', attribute_value)
+    end
+  end
+
+  def serialize_multienum_value(attribute_value, attribute_definition)
+    attribute_value = attribute_value.map(&:to_s)
+    attribute_values = attribute_definition.values
+    forbidden_values = attribute_value - attribute_values
+    if forbidden_values.any?
+      raise_validation_error(attribute_definition.name, format_array(attribute_values),
+        attribute_value)
+    end
+    attribute_value
+  end
+
+  def serialize_reference_value(attribute_value)
+    return unless attribute_value
+    attribute_value.is_a?(BasicObj) ? attribute_value.id : attribute_value.to_s
+  end
+
+  def serialize_referencelist_value(attribute_value, attribute_definition)
+    if attribute_value.is_a?(Enumerable)
+      attribute_value.map(&method(:serialize_reference_value))
+    else
+      raise_validation_error(attribute_definition.name,
+        'Enumerable containing instances of String or Scrivito::BasicWidget', attribute_value)
+    end
+  end
+
+  def serialize_string_value(attribute_value)
+    attribute_value.to_s
+  end
+
+  def serialize_stringlist_value(attribute_value, attribute_definition)
+    if attribute_value.is_a?(Enumerable)
+      attrubute_value.map(&:to_s)
+    else
+      raise_validation_error(attribute_definition.name, 'Enumerable containing instances of String',
+        attribute_value)
+    end
+  end
+
+  def serialize_widget_value(attribute_value, attribute_definition)
+    return unless attribute_value
+    if attribute_value.is_a?(BasicWidget)
+      attribute_value.id
+    else
+      raise_validation_error(attribute_definition.name, 'an instance of Scrivito::BasicWidget',
+        attribute_value)
+    end
+  end
+
+  def serialize_widgetlist_value(attribute_value, attribute_definition)
+    if attribute_value.is_a?(Enumerable) && attribute_value.all? { |item| item.is_a?(BasicWidget) }
+      attribute_value.map(&:id)
+    else
+      raise_validation_error(attribute_definition.name,
+        'Enumerable containing instances of Scrivito::BasicWidget', attribute_value)
+    end
+  end
+
+  def raise_validation_error(attribute_name, expected_value, actual_value)
+    error_message = "Unexpected value #{actual_value.inspect} for attribute '#{attribute_name}'."\
+      " Expected: #{expected_value}."
+    raise ClientError.new(error_message, 412)
+  end
+
+  def format_array(values)
+    values.map(&:inspect).to_sentence(two_words_connector: ' or ', last_word_connector: ' or ')
+  end
+end
+
+end

data/lib/scrivito/basic_obj.rb

@@ -3,13 +3,31 @@ require 'ostruct'
 require 'active_model/naming'
 
 module Scrivito
+  #
   # The abstract base class for cms objects.
   #
   # @note Please do not use {Scrivito::BasicObj} directly,
   #   as it is intended as an abstract class.
   #   Always use {Obj} or a subclass of {Obj}.
   # @api public
+  #
   class BasicObj
+    # @!parse extend Scrivito::AttributeContent::ClassMethods
+
+    PublicSystemAttributeDefinition = Class.new(AttributeDefinition)
+
+    SYSTEM_ATTRIBUTES = AttributeDefinitionCollection.new(
+      '_id'           => PublicSystemAttributeDefinition.new(:_id, :string),
+      '_last_changed' => PublicSystemAttributeDefinition.new(:_last_changed, :date),
+      '_obj_class'    => PublicSystemAttributeDefinition.new(:_obj_class, :string),
+      '_path'         => PublicSystemAttributeDefinition.new(:_path, :string),
+      '_permalink'    => PublicSystemAttributeDefinition.new(:_permalink, :string),
+
+      '_conflicts'    => AttributeDefinition.new(:_conflicts, nil),
+      '_modification' => AttributeDefinition.new(:_modification, nil),
+      '_widget_pool'  => AttributeDefinition.new(:_widget_pool, nil),
+    )
+
     UNIQ_ATTRIBUTES = %w[
       _id
       _path
@@ -37,6 +55,7 @@ module Scrivito
       @_type_computer = nil
     end
 
+    #
     # Create a new {Scrivito::BasicObj Obj} in the cms
     #
     # This allows you to set the different attributes types of an obj by
@@ -92,13 +111,18 @@ module Scrivito
     # @api public
     # @param [Hash] attributes
     # @return [Obj] the newly created {Scrivito::BasicObj Obj}
-    def self.create(attributes)
-      attributes = with_default_obj_class(attributes)
-      api_attributes, widget_properties = prepare_attributes_for_rest_api(attributes, nil)
-      json = Workspace.current.api_request(:post, '/objs', obj: api_attributes)
-      obj = find(json['_id'])
-      CmsRestApi::WidgetExtractor.notify_persisted_widgets(obj, widget_properties)
-      obj
+    #
+    def self.create(attributes = {})
+      if obj_class = extract_obj_class_from_attributes(attributes)
+        obj_class.create(attributes)
+      else
+        attributes = prepare_attributes_for_instantiation(attributes)
+        api_attributes, widget_properties = prepare_attributes_for_rest_api(attributes)
+        json = Workspace.current.api_request(:post, '/objs', obj: api_attributes)
+        obj = find(json['_id'])
+        CmsRestApi::WidgetExtractor.notify_persisted_widgets(obj, widget_properties)
+        obj
+      end
     end
 
     # Create a new {Scrivito::BasicObj Obj} instance with the given values and attributes.
@@ -171,7 +195,6 @@ module Scrivito
       if self == ::Obj
         Workspace.current.objs.where(field, operator, value, boost)
       else
-        assert_has_obj_class('.where')
         Workspace.current.objs.where(:_obj_class, :equals, name)
             .and(field, operator, value, boost)
       end
@@ -188,7 +211,6 @@ module Scrivito
       if self == ::Obj
         Workspace.current.objs.all
       else
-        assert_has_obj_class('.all')
         find_all_by_obj_class(name)
       end
     end
@@ -401,7 +423,6 @@ module Scrivito
       root
     end
 
-    # @api private
     def self.generate_widget_pool_id
       SecureRandom.hex(4)
     end
@@ -489,12 +510,8 @@ module Scrivito
     #
     # @return true if this Obj represents a binary resource.
     def binary?
-      if obj_type = read_attribute('_obj_type')
-        [:image, :generic].include?(obj_type.to_sym)
-      else
-        blob_attribute = obj_class.attributes['blob']
-        blob_attribute && blob_attribute.type == 'binary'
-      end
+      blob_attribute_definition = attribute_definitions['blob']
+      blob_attribute_definition.present? && blob_attribute_definition.type == 'binary'
     end
 
     # Returns true if this object is the root object.
@@ -523,7 +540,7 @@ module Scrivito
     end
 
     # This should be a SET, because it's faster in this particular case.
-    INTERNAL_KEYS = Set.new(%w[
+    SYSTEM_KEYS = Set.new(%w[
       body
       _id
       _last_changed
@@ -533,12 +550,12 @@ module Scrivito
       title
     ])
 
-    # Returns the value of an internal or external attribute specified by its name.
+    # Returns the value of an system or custom 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 INTERNAL_KEYS.include?(key)
+      if SYSTEM_KEYS.include?(key)
         read_attribute(key)
       else
         super
@@ -548,7 +565,7 @@ module Scrivito
     def has_attribute?(key)
       key = key.to_s
 
-      if INTERNAL_KEYS.include?(key)
+      if SYSTEM_KEYS.include?(key)
         true
       else
         super
@@ -596,14 +613,14 @@ module Scrivito
 
     def modification(revision=workspace.base_revision)
       return Modification::UNMODIFIED unless revision
-
-      obj_data_from_revision = cms_data_for_revision(revision)
+      return read_attribute('_modification') if revision == workspace.base_revision
 
       if deleted?(revision)
         Modification::DELETED
       elsif new?(revision)
         Modification::NEW
       else # Edited
+        obj_data_from_revision = cms_data_for_revision(revision)
         if obj_data_from_revision.present?
           if data_from_cms == obj_data_from_revision
             Modification::UNMODIFIED
@@ -789,10 +806,10 @@ module Scrivito
       end
 
       widget_copy = widget.copy_for_restore(read_widget_pool.keys)
-      field_name = widget.container_field_name
+      attribute_name = widget.container_attribute_name
       current_container = widgets[container.id] || self
-      current_container.update(field_name =>
-        current_container[field_name].insert(widget.container_field_index, widget_copy))
+      current_container.update(attribute_name =>
+        current_container[attribute_name].insert(widget.container_attribute_index, widget_copy))
     end
 
     def mark_resolved
@@ -800,16 +817,17 @@ module Scrivito
       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
+    def find_container_and_attribute_name_for_widget(widget_id)
+      if attribute_name = find_attribute_containing_widget(widget_id)
+        return [self, attribute_name]
+      end
+
+      all_widgets_from_pool.each do |container_widget|
+        if attribute_name = container_widget.find_attribute_containing_widget(widget_id)
+          return [container_widget, attribute_name]
         end
       end
+
       [nil, nil]
     end
 
@@ -841,34 +859,16 @@ module Scrivito
       raise ScrivitoError.new('Could not generate a new unused widget id')
     end
 
-    #
-    # Generates a +Hash+ containing all public attributes. The hash will _not_ include attributes,
-    # which are read-only or used for internal purpose.
-    #
-    # @api private
-    # @return [Hash] a hash containing all public attributes.
-    #
-    # @example
-    #   old_obj = Obj.homepage
-    #   attrs = old_obj.to_h
-    #   puts attrs
-    #   #=> {"_obj_class"=>"Publication", "_path"=>"/", "_id"=>"f64a68258ca15faf", "_widget_pool"=>{}}
-    #   old_obj.destroy
-    #
-    #   new_obj = Obj.create(attrs)
-    #   puts new_obj == old_obj
-    #   #=> true
-    #
-    def to_h
-      data_from_cms.to_h.except(*GENERATED_ATTRIBUTES)
-    end
-
     def parent_path
       unless root? || path.nil?
         path.gsub(/\/[^\/]+$/, '').presence || '/'
       end
     end
 
+    def as_client_json
+      data_from_cms.to_h.except(*GENERATED_ATTRIBUTES)
+    end
+
     private
 
     def cms_data_for_revision(revision)
@@ -877,13 +877,6 @@ module Scrivito
       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
@@ -940,8 +933,24 @@ module Scrivito
       "#{obj_class_name.underscore}/#{view_name}"
     end
 
-    class << self
+    def has_system_attribute?(attribute_name)
+      !!SYSTEM_ATTRIBUTES[attribute_name]
+    end
+
+    def has_public_system_attribute?(attribute_name)
+      SYSTEM_ATTRIBUTES[attribute_name].is_a?(PublicSystemAttributeDefinition)
+    end
 
+    def type_of_system_attribute(attribute_name)
+      SYSTEM_ATTRIBUTES[attribute_name].try(:type)
+    end
+
+    def value_of_system_attribute(attribute_name)
+      attribute_value = data_from_cms.value_of(attribute_name)
+      attribute_name == '_last_changed' ? DateAttribute.parse(attribute_value) : attribute_value
+    end
+
+    class << self
       def assert_not_basic_obj(method_name)
         if self == Scrivito::BasicObj
           raise ScrivitoError, "Can not call #{method_name} on Scrivito::BasicObj."
@@ -949,13 +958,6 @@ module Scrivito
         end
       end
 
-      def assert_has_obj_class(method_name)
-        unless Workspace.current.obj_classes[name].present?
-          raise ScrivitoError, "#{name} has no corresponding ObjClass."
-            + " Please use Obj.#{method_name} instead."
-        end
-      end
-
       #
       # Restores a previously deleted +Obj+.
       #
@@ -971,21 +973,54 @@ module Scrivito
         Workspace.current.api_request(:post, '/objs', obj: obj_attributes)
       end
 
-      def prepare_attributes_for_rest_api(attributes, obj)
-        widget_properties = CmsRestApi::WidgetExtractor.call(attributes, obj)
-        api_attributes = CmsRestApi::AttributeSerializer.convert(attributes)
-        api_attributes['_widget_pool'] =
-            CmsRestApi::AttributeSerializer.generate_widget_pool_changes(widget_properties)
+      def prepare_attributes_for_rest_api(obj_attributes, obj = nil)
+        widget_pool_attributes = CmsRestApi::WidgetExtractor.call(obj_attributes, obj)
+        workspace = obj ? obj.revision.workspace : Workspace.current
+        api_attributes = serialize_attributes(obj_attributes, widget_pool_attributes, workspace)
 
         if obj
           widget_pool = api_attributes['_widget_pool']
-          widget_gc = WidgetGarbageCollection.new(obj, {obj => attributes}.merge(widget_properties))
+          widget_gc = WidgetGarbageCollection.new(obj,
+            {obj => obj_attributes}.merge(widget_pool_attributes))
           widget_gc.widgets_to_delete.each { |widget| widget_pool[widget.id] = nil }
         end
 
-        [api_attributes, widget_properties]
+        [api_attributes, widget_pool_attributes]
+      end
+
+      def serialize_attributes(obj_attributes, widget_pool_attributes, workspace)
+        if workspace.uses_obj_classes
+          serialized_attributes = CmsRestApi::LegacyAttributeSerializer.convert(obj_attributes)
+          serialized_attributes['_widget_pool'] = CmsRestApi::LegacyAttributeSerializer
+            .generate_widget_pool_changes(widget_pool_attributes)
+          serialized_attributes
+        else
+          serializer = AttributeSerializer.new
+          serialized_attributes = serialize_obj_attributes(serializer, obj_attributes)
+          serialized_attributes['_widget_pool'] =
+            serialize_widget_pool_attributes(serializer, widget_pool_attributes)
+          serialized_attributes
+        end
+      end
+
+      def serialize_obj_attributes(serializer, obj_attributes)
+        serializer.serialize(obj_attributes,
+          find_attribute_definitions(obj_attributes['_obj_class']) || attribute_definitions)
+      end
+
+      def serialize_widget_pool_attributes(serializer, widget_pool_attributes)
+        {}.tap do |serialized_attributes|
+          widget_pool_attributes.each_pair do |widget, widget_attributes|
+            obj_class = widget_attributes['_obj_class']
+            serialized_attributes[widget.id] = serializer.serialize(widget_attributes,
+              find_attribute_definitions(obj_class, BasicWidget) || widget.attribute_definitions)
+          end
+        end
+      end
+
+      def find_attribute_definitions(obj_class, basic_class = self)
+        basic_class.type_computer.compute_type(obj_class).attribute_definitions if obj_class
       end
     end
   end
-
 end