infopark_fiona7 1.2.0.0.1 → 1.2.0.1.1

data/lib/fiona7/attribute_readers/simple.rb

@@ -0,0 +1,18 @@
+require 'fiona7/attribute_readers/attribute_reader'
+
+module Fiona7
+  module AttributeReaders
+    class Simple < AttributeReader
+      def call
+        value = self.obj[self.attr_name]
+
+        if self.attr_name.to_s == "suppress_export"
+          value.to_s
+        else
+          value
+        end
+      end
+    end
+  end
+end
+

data/lib/fiona7/attribute_readers/stringlist_as_text.rb

@@ -0,0 +1,18 @@
+require 'fiona7/attribute_readers/attribute_reader'
+require 'fiona7/attribute_readers/helpers/json_deserializer'
+
+module Fiona7
+  module AttributeReaders
+    class StringlistAsText < AttributeReader
+      def call
+        if self.attr_name.to_s == "channels"
+          self.obj["channels"] || []
+        else
+          value = self.obj[self.attr_name]
+          Helpers::JsonDeserializer.new.call(value).presence || []
+        end
+      end
+    end
+  end
+end
+

data/lib/fiona7/attribute_readers/widgetlist_as_linklist.rb

@@ -0,0 +1,33 @@
+require 'fiona7/attribute_readers/attribute_reader'
+
+module Fiona7
+  module AttributeReaders
+    class WidgetlistAsLinklist < AttributeReader
+      def call
+        linklist = self.obj.attr_values[self.attr_name] || []
+        if !linklist.empty?
+          widget_ids = []
+          widgets = linklist.map do |link|
+            widget_id = link["title"]
+            # sometimes a released page references an unreleased widget
+            # it is then impossible to load it into widget_pool
+            # but the reference in the widgetlist field is still there
+            # therefore we need to check if the widget has been loaded
+            # into the pool - only then it can be included
+            if valid_widget_id?(widget_id)
+              widget_ids << widget_id
+            end
+          end
+
+          widget_ids
+        end
+      end
+
+      protected
+      def valid_widget_id?(widget_id)
+        self.widget_resolver && self.widget_resolver.path_map[widget_id]
+      end
+    end
+  end
+end
+

data/lib/fiona7/attribute_type_mapper.rb

@@ -0,0 +1,76 @@
+module Fiona7
+  # This class is used to map from virtual attribute types
+  # to real attribute types.
+  # For example number to string or referencelist to linklist
+  class AttributeTypeMapper
+    def initialize(obj_class, source=Fiona7.custom_attribute_types)
+      self.custom = CustomAttributeTypeMapper.new(obj_class, source)
+      self.built_in = BuiltInTypeMapper.new(obj_class)
+    end
+
+    def call(attribute, virtual_type)
+      self.validate!(attribute,
+        self.custom.call(attribute, virtual_type) ||
+        self.built_in.call(attribute, virtual_type)
+      )
+    end
+
+    protected
+    attr_accessor :custom, :built_in
+
+    def validate!(attribute, mapped_type)
+      [:string, :text, :enum, :multienum,
+       :linklist, :html, :markdown, :date].include?(mapped_type) ||
+      raise(Fiona7::TypeSystemError.new("Unhandled mapping for attribute #{attribute} in #{obj_class}: #{mapped_type}"))
+
+      return mapped_type
+    end
+
+    class CustomAttributeTypeMapper
+      def initialize(obj_class, source)
+        self.obj_class = obj_class
+        self.source = source
+      end
+
+      def call(attribute, virtual_type)
+        return nil if source.kind_of?(Hash) && source.empty?
+
+        if source.kind_of? Hash
+          (source[self.obj_class] || {})[attribute] || source[attribute]
+        elsif source.respond_to? :call
+          source.call(self.obj_class, attribute)
+        else
+          nil
+        end
+      end
+
+      protected
+      attr_accessor :obj_class, :source
+    end
+
+    class BuiltInTypeMapper
+      BUILT_IN_TYPE_MAP = {
+        linklist:    :linklist,
+        string:      :string,
+        date:        :date,
+        html:        :html,
+        enum:        :enum,
+        multienum:   :multienum,
+        markdown:    :markdown,
+        signature:   :signature
+      }.freeze
+
+      def initialize(obj_class)
+        self.obj_class = obj_class
+      end
+
+      def call(attribute, virtual_type)
+        Fiona7::TypeRegister::TYPE_MAP[virtual_type] ||
+          BUILT_IN_TYPE_MAP[virtual_type]
+      end
+
+      protected
+      attr_accessor :obj_class
+    end
+  end
+end

data/lib/fiona7/attribute_writers/attribute_writer.rb

@@ -0,0 +1,16 @@
+module Fiona7
+  module AttributeWriters
+    class AttributeWriter
+      def initialize(obj, attr_name, obj_class, klass, widget_map)
+        self.obj        = obj
+        self.attr_name  = attr_name
+        self.obj_class  = obj_class
+        self.klass      = klass
+        self.widget_map = widget_map
+      end
+
+      protected
+      attr_accessor :obj, :attr_name, :obj_class, :klass, :widget_map
+    end
+  end
+end

data/lib/fiona7/attribute_writers/binary_as_binary.rb

@@ -0,0 +1,74 @@
+require 'fiona7/attribute_writers/attribute_writer'
+
+
+module Fiona7
+  module AttributeWriters
+    class BinaryAsBinary < AttributeWriter
+      def call(value, claimed_type=nil)
+        if value.kind_of?(File)
+          self.special_upload_handling(self.attr_name, value)
+        elsif value.kind_of?(ActionDispatch::Http::UploadedFile)
+          self.special_upload_uploaded_handling(self.attr_name, value)
+        elsif value.nil?
+          self.obj.set(self.attr_name, '')
+        elsif value.kind_of?(Hash)
+          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 self.obj.set(), but calling self.obj.save
+          # afterwards still persists the data correctly
+          #
+          # This works the same way as Reactor::Tools::Uploader
+          Fiona7::Builder::LazyBlobCopier.new({
+            destination_obj:  self.obj,
+            attr_name:        self.attr_name,
+            source_blob_id:   source_blob_id,
+            filename:         filename,
+            content_type:     content_type
+          }).call
+
+          # NOTE: no self.obj.set() required here
+        else
+          raise Scrivito::ClientError.new("Invalid input for binary field", 422)
+        end
+      end
+
+      protected
+
+      def special_upload_handling(attribute_name, file)
+        if !self.obj.binary?
+          # standard handling!
+          self.obj.set(attribute_name.to_s, self.upload_file(file))
+        else
+          ext  = ::File.extname(file.path).to_s[1..-1]
+          self.obj.upload(file, ext)
+        end
+      end
+
+      def special_upload_uploaded_handling(attribute_name, file)
+        if !self.obj.binary?
+          # standard handling!
+          self.obj.set(attribute_name.to_s, self.upload_uploaded_file(file))
+        else
+          ext  = ::File.extname(file.original_filename).to_s[1..-1]
+          self.obj.upload(file.open, ext)
+        end
+      end
+
+      def upload_file(file)
+        upload = Fiona7::Builder::IndirectBlobBuilder.new(self.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)
+        upload = Fiona7::Builder::IndirectBlobBuilder.new(self.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
+    end
+  end
+end

data/lib/fiona7/attribute_writers/binary_as_linklist.rb

@@ -0,0 +1,86 @@
+require 'fiona7/attribute_writers/attribute_writer'
+
+
+module Fiona7
+  module AttributeWriters
+    class BinaryAsLinklist < AttributeWriter
+      def call(value, claimed_type=nil)
+        if value.kind_of?(String)
+          # NOTE: this code path has not been tested yet.
+          target = {title: value, destination_object: InternalReleasedObj.find(value.to_i)}
+          self.obj.set(self.attr_name, target)
+        elsif value.kind_of?(File)
+          if !Fiona7.mode == :legacy || self.attr_name != "blob"
+            self.obj.set(self.attr_name, self.upload_file(value))
+          else
+            self.special_upload_handling(self.attr_name, value)
+          end
+        elsif value.kind_of?(ActionDispatch::Http::UploadedFile)
+          if !Fiona7.mode == :legacy || self.attr_name != "blob"
+            self.obj.set(self.attr_name, self.upload_uploaded_file(value))
+          else
+            self.special_upload_uploaded_handling(self.attr_name, value)
+          end
+        elsif value.nil?
+          self.obj.set(self.attr_name, [])
+        elsif value.kind_of?(Hash)
+          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 self.obj.set(), but calling self.obj.save
+          # afterwards still persists the data correctly
+          #
+          # This works the same way as Reactor::Tools::Uploader
+          Fiona7::Builder::LazyBlobCopier.new({
+            destination_obj:  self.obj,
+            attr_name:        self.attr_name,
+            source_blob_id:   source_blob_id,
+            filename:         filename,
+            content_type:     content_type
+          }).call
+
+          # NOTE: no self.obj.set() required here
+        else
+          raise Scrivito::ClientError.new("Invalid input for binary field", 422)
+        end
+      end
+
+      protected
+
+      def special_upload_handling(attribute_name, file)
+        if !self.obj.binary?
+          # standard handling!
+          self.obj.set(attribute_name.to_s, self.upload_file(file))
+        else
+          ext  = ::File.extname(file.path).to_s[1..-1]
+          self.obj.upload(file, ext)
+        end
+      end
+
+      def special_upload_uploaded_handling(attribute_name, file)
+        if !self.obj.binary?
+          # standard handling!
+          self.obj.set(attribute_name.to_s, self.upload_uploaded_file(file))
+        else
+          ext  = ::File.extname(file.original_filename).to_s[1..-1]
+          self.obj.upload(file.open, ext)
+        end
+      end
+
+      def upload_file(file)
+        upload = Fiona7::Builder::IndirectBlobBuilder.new(self.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)
+        upload = Fiona7::Builder::IndirectBlobBuilder.new(self.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
+    end
+  end
+end

data/lib/fiona7/attribute_writers/date_as_date.rb

@@ -0,0 +1,11 @@
+require 'fiona7/attribute_writers/attribute_writer'
+
+module Fiona7
+  module AttributeWriters
+    class DateAsDate < AttributeWriter
+      def call(value, claimed_type=nil)
+        self.obj.set(self.attr_name, value)
+      end
+    end
+  end
+end

data/lib/fiona7/attribute_writers/factory.rb

@@ -0,0 +1,90 @@
+require 'fiona7/attribute_writers/binary_as_binary'
+require 'fiona7/attribute_writers/binary_as_linklist'
+require 'fiona7/attribute_writers/html_as_html'
+require 'fiona7/attribute_writers/link_as_linklist'
+require 'fiona7/attribute_writers/linklist_as_linklist'
+require 'fiona7/attribute_writers/multienum_as_multienum'
+require 'fiona7/attribute_writers/multienum_as_text'
+require 'fiona7/attribute_writers/number_as_string'
+require 'fiona7/attribute_writers/reference_as_linklist'
+require 'fiona7/attribute_writers/reference_as_string'
+require 'fiona7/attribute_writers/referencelist_as_linklist'
+require 'fiona7/attribute_writers/referencelist_as_text'
+require 'fiona7/attribute_writers/simple'
+require 'fiona7/attribute_writers/date_as_date'
+require 'fiona7/attribute_writers/stringlist_as_text'
+require 'fiona7/attribute_writers/widgetlist_as_linklist'
+
+
+module Fiona7
+  module AttributeWriters
+    class Factory
+      def initialize(obj, obj_class, klass, widget_map)
+        self.obj        = obj
+        self.obj_class  = obj_class
+        self.klass      = klass
+        self.widget_map = widget_map
+
+        self.type_def   = Fiona7::TypeRegister.instance.write(self.obj_class) || raise(Fiona7::TypeSystemError.new("Obj class definition not found for #{self.obj_class}"))
+      end
+
+      def call(attribute)
+        attr_def = self.type_def.find_attribute(attribute) ||
+          raise(Fiona7::TypeSystemError.new("Attribute #{attribute} not found in #{self.obj_class}"))
+
+        virtual  = attr_def.type.to_sym
+        real     = attr_def.real_type.to_sym
+
+        worker = case [virtual, real]
+                 when [:linklist, :linklist]
+                   Fiona7::AttributeWriters::LinklistAsLinklist
+                 when [:link, :linklist]
+                   Fiona7::AttributeWriters::LinkAsLinklist
+                 when [:reference, :linklist]
+                   Fiona7::AttributeWriters::ReferenceAsLinklist
+                 when [:reference, :string], [:reference, :text]
+                   Fiona7::AttributeWriters::ReferenceAsString
+                 when [:referencelist, :linklist]
+                   Fiona7::AttributeWriters::ReferencelistAsLinklist
+                 when [:referencelist, :text], [:referencelist, :string]
+                   Fiona7::AttributeWriters::ReferencelistAsText
+                 when [:widgetlist, :linklist]
+                   Fiona7::AttributeWriters::WidgetlistAsLinklist
+                 when [:multienum, :text], [:multienum, :string]
+                   Fiona7::AttributeWriters::MultienumAsText
+                 when [:multienum, :multienum]
+                   Fiona7::AttributeWriters::MultienumAsMultienum
+                 when [:number, :string], [:number, :text]
+                   Fiona7::AttributeWriters::NumberAsString
+                 when [:html, :html]
+                   Fiona7::AttributeWriters::HtmlAsHtml
+                 when [:binary, :linklist]
+                   Fiona7::AttributeWriters::BinaryAsLinklist
+                 when [:binary, :binary]
+                   Fiona7::AttributeWriters::BinaryAsBinary
+                 when [:stringlist, :text], [:stringlist, :string]
+                   Fiona7::AttributeWriters::StringlistAsText
+                 when [:stringlist, :multienum]
+                   Fiona7::AttributeWriters::Simple
+                 when [:stringlist, :stringlist]
+                   # NOTE: this is practically only used for "channels"
+                   Fiona7::AttributeWriters::Simple
+                 else
+                   case virtual
+                   when :text, :string, :enum, :markdown
+                     Fiona7::AttributeWriters::Simple
+                   when :date
+                     Fiona7::AttributeWriters::DateAsDate
+                   else
+                     raise(Fiona7::TypeSystemError.new("Unable to write #{attribute} in #{self.obj_class} with typing #{virtual}:#{real}"))
+                   end
+                 end
+
+        worker.new(self.obj, attr_def.real_name.to_s, self.obj_class, self.klass, self.widget_map)
+      end
+
+      protected
+      attr_accessor :obj, :obj_class, :klass, :widget_map, :type_def
+    end
+  end
+end

data/lib/fiona7/attribute_writers/helpers/html_serializer.rb

@@ -0,0 +1,21 @@
+require 'fiona7/link_converter/scrivito_to_fiona'
+
+module Fiona7
+  module AttributeWriters
+    module Helpers
+      class HtmlSerializer
+        def initialize(obj, klass)
+          self.obj   = obj
+          self.klass = klass
+        end
+
+        def call(value)
+          converted_links = LinkConverter::ScrivitoToFiona.new(self.klass, value.to_s).convert
+        end
+
+        protected
+        attr_accessor :obj, :klass
+      end
+    end
+  end
+end