infopark_fiona7 1.1.0.0.10 → 1.2.0.0.0

data/infopark_fiona7.gemspec

@@ -17,11 +17,11 @@ Gem::Specification.new do |s|
   s.files = Dir["{app,config,db,lib}/**/*", "Rakefile", "README.md", "infopark_fiona7.gemspec"]
 
   s.add_dependency "rails", "~> 4.2.2"
-  s.add_dependency "scrivito", "= 1.1.0"
+  s.add_dependency "scrivito", "= 1.2.0"
   s.add_dependency "scrivito_sdk"
   s.add_dependency "scrivito_editors"
   s.add_dependency "infopark_fiona_connector", "= 7.0.1.beta2"
-  s.add_dependency "infopark_reactor", ">= 1.18.0"
+  s.add_dependency "infopark_reactor", ">= 1.22.3"
   s.add_dependency "mini_magick"
   #s.add_development_dependency "ruby-prof"
 end

data/lib/fiona7/blob_id_generator.rb

@@ -0,0 +1,13 @@
+module Fiona7
+  class BlobIdGenerator
+    def initialize(obj_id, time=nil)
+      @obj_id = obj_id.to_i
+      @time   = time || Time.now
+      @stamp  = @time.to_i.to_s(16)
+    end
+
+    def call
+      ("%022d" % @obj_id) + "bb" + @stamp
+    end
+  end
+end

data/lib/fiona7/builder/indirect_blob_builder.rb

@@ -0,0 +1,71 @@
+module Fiona7
+  module Builder
+    class IndirectBlobBuilder
+      def initialize(obj, filename, file=nil)
+        @obj = obj
+        @filename = filename
+        @file = file
+      end
+
+      def call
+        # only publication type can contain children (code = "5")
+        if @obj.obj_type_code != "5" || @obj.id == 2001
+          parent_path = "/_uploads/#{@obj.id}"
+        else
+          parent_path = "#{@obj.path}/_uploads"
+        end
+
+        parent    = ensure_parent_exists(parent_path)
+        ext       = ::File.extname(@filename).to_s[1..-1]
+        name      = ::File.basename(@filename, '.' + ext.to_s)
+        obj_class = if ['jpg', 'jpeg', 'gif', 'png', 'tif', 'tiff'].include?(ext)
+                      'X_Image'
+                    else
+                      'X_Generic'
+                    end
+
+        if @file
+          upload = WriteObj.upload(@file, ext, {name: name, parent: parent, obj_class: obj_class}).tap(&:release!)
+        else
+          upload = WriteObj.create({name: name, parent: parent, obj_class: obj_class}).tap(&:release!)
+        end
+      end
+
+      protected
+      # TODO: extract this code
+      def ensure_parent_exists(path)
+        remaining  = path.split("/")
+        current    = []
+        paths      = []
+        original   = path
+
+        while !remaining.empty?
+          current.push(remaining.shift)
+
+          path = current.join('/').presence || '/'
+          paths.push(path)
+        end
+
+        # TODO: add an optimization for exiting parents
+
+        paths.each do |path|
+          if !WriteObj.exists?(path: path)
+            name, parent_path = name_and_parent_path_from_path(path)
+            WriteObj.create!(name: name, parent_obj_id: WriteObj.find_by_path(parent_path).id, obj_class: 'X_Container')
+          end
+        end
+
+        WriteObj.find_by_path(original) || (raise "Tried to make sure that the parent under '#{original}' exist, but it does not :(")
+      end
+
+      def name_and_parent_path_from_path(path)
+        components = path.split('/')
+        name       = components.pop.presence
+        parent_path= components.join('/').presence || '/'
+
+        return name, parent_path
+      end
+    end
+  end
+end
+

data/lib/fiona7/builder/lazy_blob_copier.rb

@@ -0,0 +1,207 @@
+require 'fiona7/super_object_finder'
+require 'fiona7/blob_id_generator'
+require 'fiona7/builder/indirect_blob_builder'
+
+module Fiona7
+  module Builder
+    # This class implements a lazy blob copy/rename operation.
+    #
+    # Blob copy is trivial: an existing blob is taken
+    # and copied to the destination object.
+    #
+    # Blob rename occurs, when an apparent copy is executed,
+    # that is the blob that is copied is already associated
+    # with this object (and only with this object)
+    #
+    # The lazy part of this class is the fact that you
+    # need to call .save! on the passed destination obj
+    # to actually persist the changes in the obj
+    #
+    # NOTE: there is an exception to the above:
+    # renaming a blob in standalone mode executes immediately
+    class LazyBlobCopier
+      def initialize(attrs={})
+        @destination_obj = attrs[:destination_obj]
+        @attribute       = attrs[:attr_name] || 'blob'
+        @source_blob_id  = attrs[:source_blob_id]
+        @filename        = attrs[:filename]
+        @content_type    = attrs[:content_type]
+
+        @basename, @ext  = *split_filename(@filename)
+      end
+
+      def call
+        validate_input!
+
+        @blob_obj   = Fiona7::WriteObj.find(@source_blob_id.to_i)
+        @source_obj = find_unique_source_obj
+
+        if @destination_obj == @source_obj
+          rename
+        else
+          copy
+        end
+
+        return {id: @destination_blob_id}
+      end
+
+      protected
+
+      def rename
+        return unless @basename.present? && @ext.present?
+
+        if Fiona7.mode == :legacy
+          direct_rename
+        else
+          indirect_rename
+        end
+      end
+
+      def copy
+        if Fiona7.mode == :legacy
+          direct_copy
+        else
+          indirect_copy
+        end
+      end
+
+      def direct_rename
+        @destination_obj.set(:name, @basename)
+        # CM stores the file extension as :contentType and not the mimetype
+        @destination_obj.set(:content_type, @ext)
+
+        @destination_blob_id = Fiona7::BlobIdGenerator.new(@destination_obj.id).call
+      end
+
+      def indirect_rename
+        # This is kind of silly, but as far as I can tell there is no way
+        # around it: whenever you rename a blob, you will also rename
+        # it in the published workspace.
+        # Basically the same design flaw as in the "classical" CM
+        #
+        # NOTE: this applies the change directly, whether a "save"
+        # happens afterwards on not, so it breaks the "lazy" part
+        # of the contract
+        @blob_obj.set(:name, @basename)
+        @blob_obj.set(:content_type, @ext)
+        @blob_obj.save!
+        # Just for good measure, since contentType is a content attribute
+        @blob_obj.release
+        # And now for the "lazy" part, we have to update the linklist with
+        # new "fake" blob id to fool SDK into thinking we actually copied
+        # the blob
+        @destination_blob_id = Fiona7::BlobIdGenerator.new(@blob_obj.id, @blob_obj.last_changed).call
+        @destination_obj.set(@attribute, {
+          title:                @destination_blob_id,
+          destination_object:   @blob_obj
+        })
+      end
+
+      def direct_copy
+        @destination_blob_id = Fiona7::BlobIdGenerator.new(@destination_obj.id).call 
+
+        content = @blob_obj.edited? ? 'edited' : 'released'
+
+        begin
+          blob_ticket_id = @blob_obj.send(:crul_obj).blob_ticket_id(content)
+          target         = @destination_obj.send(:crul_obj)
+
+          target.set(:blob, {blob_ticket_id => {encoding: 'stream'}})
+        rescue Reactor::Cm::BlobTooSmallError
+          # Reading blob_ticket_id failed,
+          # an alternative strategy is required:
+          # reading into memory
+          @destination_obj.set(:blob, @blob_obj.body)
+        end
+
+        if @basename.present? && @ext.present?
+          direct_rename
+        end
+
+        # NOTE: calling @destination_obj.save! will trigger target.save!
+      end
+
+      def indirect_copy
+        destination_blob = construct_destination_blob
+
+        # NOTE: this should under normal circumstances
+        # never return 'edited'. But this is on the safe side
+        content = @blob_obj.edited? ? 'edited' : 'released'
+
+        begin
+          blob_ticket_id = @blob_obj.send(:crul_obj).blob_ticket_id(content)
+          target         = destination_blob.send(:crul_obj)
+
+          target.set(:blob, {blob_ticket_id => {encoding: 'stream'}})
+        rescue Reactor::Cm::BlobTooSmallError
+          # Reading blob_ticket_id failed,
+          # an alternative strategy is required:
+          # reading into memory
+          destination_blob.set(:blob, @blob_obj.body)
+        end
+
+        # NOTE: this will also call target.save!
+        destination_blob.save!
+        destination_blob.release
+
+        @destination_blob_id = Fiona7::BlobIdGenerator.new(destination_blob.id, destination_blob.last_changed).call
+
+        @destination_obj.set(@attribute, {
+          title: @destination_blob_id, destination_object: destination_blob
+        })
+      end
+
+      def split_filename(filename)
+        return unless filename
+
+        ext  = ::File.extname(filename)[1..-1]
+        base = ::File.basename(filename, ::File.extname(filename))
+
+        return base, ext
+      end
+
+      def validate_input!
+        if Fiona7.mode == :legacy && @attribute != 'blob'
+          raise Scrivito::ClientError.new("Blob attributes other than :blob are unsupported in :legacy mode")
+        end
+        if !extension_and_content_type_match?
+          Rails.logger.error("BLOB COPY ERROR: content_type passed to the blob copy operation ignored, because it does not match the file extension")
+        end
+        if !@destination_obj.kind_of?(Fiona7::WriteObj)
+          raise ArgumentError, "Wrong input for LazyBlobCopier"
+        end
+      end
+
+      def extension_and_content_type_match?
+        return true if @content_type.blank?
+        return false if @ext.blank?
+
+        return MIME::Types.type_for(@ext).any? {|m| m.content_type == @content_type }
+      #rescue
+        return false
+      end
+
+      def find_unique_source_obj
+        if Fiona7.mode == :legacy
+          return @blob_obj
+        end
+
+        linking = Fiona7::SuperObjectFinder.new.find(@blob_obj)
+
+        if linking.count == 1
+          return linking.first
+        else
+          return nil
+        end
+      rescue ActiveRecord::RecordNotFound
+        return nil
+      end
+
+      def construct_destination_blob
+        filename = @filename || (@source_obj.name + "." + @source_obj.file_extension)
+        Fiona7::Builder::IndirectBlobBuilder.new(@destination_obj, filename).call
+
+      end
+    end
+  end
+end

data/lib/fiona7/builder/obj_builder.rb

@@ -13,6 +13,9 @@ require 'fiona7/obj_class_name_demangler'
 require 'fiona7/builder/batch_widget_writer'
 require 'fiona7/link_converter/scrivito_to_fiona'
 require 'fiona7/widget_resolver'
+require 'fiona7/builder/lazy_blob_copier'
+require 'fiona7/builder/indirect_blob_builder'
+require 'fiona7/blob_id_generator'
 
 
 module Fiona7
@@ -25,7 +28,6 @@ module Fiona7
         @values.delete(:_modification)
         # revert command sends this info. which is silly.
         @values.delete(:_last_changed)
-        #puts "CREATING/UPDATING: #{@values.inspect}"
       end
 
       def build
@@ -218,6 +220,8 @@ module Fiona7
             #if value.nil? && value != @obj[attribute_name]
             @obj.set(attribute_name.to_s, value)
             #end
+          when :number
+            @obj.set(attribute_name.to_s, value.to_s)
           when :stringlist
             if Fiona7.mode == :legacy && attribute_name.to_s == "channels"
               @obj.set(:channels, value || [])
@@ -247,9 +251,25 @@ module Fiona7
             elsif value.nil?
               @obj.set(attribute_name.to_s, [])
             elsif value.kind_of?(Hash)
-              #TODO: legacy mode!
-              target = {title: value["id"], destination_object: InternalReleasedObj.find(value["id"].to_i)}
-              @obj.set(attribute_name.to_s, target)
+              source_blob_id = value["id"] || value["id_to_copy"]
+              filename       = value["filename"]
+              content_type   = value["content_type"]
+
+              # There is a little bit of magic behind this.
+              # This will pass some data directly to the crul_obj
+              # bypassing @obj.set(), but calling @obj.save
+              # afterwards still persists the data correctly
+              #
+              # This works the same way as Reactor::Tools::Uploader
+              Fiona7::Builder::LazyBlobCopier.new({
+                destination_obj:  @obj,
+                attr_name:        attribute_name.to_s,
+                source_blob_id:   source_blob_id,
+                filename:         filename,
+                content_type:     content_type
+              }).call
+
+              # NOTE: no @obj.set() required here
             else
               raise Scrivito::ClientError.new("Invalid input for binary field", 422)
             end
@@ -291,7 +311,7 @@ module Fiona7
       end
 
       def rewrite_full_text
-        full_text = ::YAML.load(@obj.attr_values["X_full_text"])
+        full_text = ::YAML.load(@obj.attr_values["X_full_text"]) rescue {}
         full_text = {} unless full_text.kind_of?(Hash)
         full_text["_widget_pool"] ||= {}
         full_text["_widget_pool"].deep_merge!(@widget_pool)
@@ -302,55 +322,14 @@ module Fiona7
       end
 
       def upload_file(file)
-        # only publication type can contain children (code = "5")
-        # also handle / this way
-        if @obj.obj_type_code != "5" || @obj.id == 2001
-          parent_path = "/_uploads/#{@obj.id}"
-        else
-          parent_path = "#{@obj.path}/_uploads"
-        end
-
-        parent    = ensure_parent_exists(parent_path)
-        ext       = ::File.extname(file.path).to_s[1..-1]
-        name      = ::File.basename(file.path, '.' + ext.to_s)
-        obj_class = if ['jpg', 'jpeg', 'gif', 'png', 'tif', 'tiff'].include?(ext)
-                      'X_Image'
-                    else
-                      'X_Generic'
-                    end
-
-        raise Scrivito::ScrivitoError.new("File extension of uploaded file cannot be identified", 422) if ext.nil?
-
-        upload = WriteObj.upload(file, ext, {name: name, parent: parent, obj_class: obj_class}).tap(&:release!)
-        encoded_id = '%032d' % upload.id
+        upload = Fiona7::Builder::IndirectBlobBuilder.new(@obj, ::File.basename(file.path), file).call
+        encoded_id = Fiona7::BlobIdGenerator.new(upload.id, upload.last_changed).call
         {title: encoded_id, destination_object: upload}
       end
 
       def upload_uploaded_file(file)
-        # FIXME: DRY 
-        # only publication type can contain children (code = "5")
-        # also handle / this way
-        if @obj.obj_type_code != "5" || @obj.id == 2001
-          parent_path = "/_uploads/#{@obj.id}"
-        else
-          parent_path = "#{@obj.path}/_uploads"
-        end
-
-        parent    = ensure_parent_exists(parent_path)
-        # here the first difference
-        ext       = ::File.extname(file.original_filename).to_s[1..-1]
-        name      = ::File.basename(file.original_filename, '.' + ext.to_s)
-        obj_class = if ['jpg', 'jpeg', 'gif', 'png', 'tif', 'tiff'].include?(ext)
-                      'X_Image'
-                    else
-                      'X_Generic'
-                    end
-
-        raise Scrivito::ScrivitoError.new("File extension of uploaded file cannot be identified", 422) if ext.nil?
-
-        # here the second difference
-        upload = WriteObj.upload(file.open, ext, {name: name, parent: parent, obj_class: obj_class}).tap(&:release!)
-        encoded_id = '%032d' % upload.id
+        upload = Fiona7::Builder::IndirectBlobBuilder.new(@obj, file.original_filename, file.open).call
+        encoded_id = Fiona7::BlobIdGenerator.new(upload.id, upload.last_changed).call
         {title: encoded_id, destination_object: upload}
       end
 

data/lib/fiona7/builder/obj_class_builder.rb

@@ -48,6 +48,26 @@ module Fiona7
               else
                 Assert.constraint(false, "Type #{attribute[:type]} requested for #{attribute[:real_name]}, but is #{cms_attribute.attribute_type}")
               end
+            elsif cms_attribute.attribute_type == "multienum" && attribute[:type] == :stringlist
+              # This is a bit of hack. This allows a multienum to exist
+              # But be treated in the application like a stringlist
+              # 
+              # The intention here is to allow dynamically restricting or allowing
+              # values in the application, while having a fixed superset of allowed
+              # values in the CMS
+              #
+              # Nothing to do.
+              Rails.logger.warn("TYPE SYNCHRONIZATION: Type #{attribute[:type]} requested for #{attribute[:real_name]}, but is #{cms_attribute.attribute_type}, this may cause errors.")
+            elsif cms_attribute.attribute_type == "enum" && attribute[:type] == :string
+              # This is a bit of hack. This allows an enum to exist
+              # But be treated in the application like a string
+              # 
+              # The intention here is to allow dynamically restricting or allowing
+              # values in the application, while having a fixed superset of allowed
+              # values in the CMS
+              #
+              # Nothing to do.
+              Rails.logger.warn("TYPE SYNCHRONIZATION: Type #{attribute[:type]} requested for #{attribute[:real_name]}, but is #{cms_attribute.attribute_type}, this may cause errors.")
             elsif attribute[:type] == :enum || attribute[:type] == :multienum
               if cms_attribute.attribute_type == "multienum" || cms_attribute.attribute_type == "enum"
                 if attribute[:values]