infopark_fiona7 0.30.0.1

data/lib/fiona7/builder/obj_builder.rb

@@ -0,0 +1,297 @@
+module Fiona7
+  module Builder
+    class ObjBuilder
+    end
+  end
+end
+
+require 'fiona7/type_register_mixin'
+require 'fiona7/recursive_link_resolver'
+#require 'fiona7/write_obj'
+#require 'fiona7/released_obj'
+require 'fiona7/builder/batch_widget_writer'
+require 'fiona7/link_converter/scrivito_to_fiona'
+require 'fiona7/widget_resolver'
+
+
+module Fiona7
+  module Builder
+    class ObjBuilder
+      include TypeRegisterMixin
+
+      def initialize(values)
+        @values = values.symbolize_keys
+      end
+
+      def build
+        assert_valid
+        prepare_object
+
+        create_object
+        write_widget_pool
+        namespace_attributes
+        store_attributes
+
+        @obj
+      end
+
+      def validate
+        true
+      end
+
+      protected
+      def assert_valid
+        validate || (raise Scrivito::ClientError.new(@error_msg || "Invalid input", 422))
+      end
+
+      def prepare_object
+        @path              = @values.delete(:_path)
+        @obj_class         = @values.delete(:_obj_class)
+        @widget_pool       = @values.delete(:_widget_pool)
+        @permalink         = @values.delete(:_permalink)
+        if @path
+          @path = "/#{@path}" unless @path.start_with?('/')
+          @name, parent_path = name_and_parent_path_from_path(@path)
+        end
+        @parent            = ensure_parent_exists(parent_path) if parent_path
+      end
+
+      def namespace_attributes
+        # nop
+      end
+
+      def create_object
+        # bottom one is faster, but can only work when there are no widgets and no uploads
+        if (@widget_pool && !@widget_pool.empty?) || (@values.any? {|_, v| v.kind_of?(File) || v.kind_of?(ActionDispatch::Http::UploadedFile) } )
+          @obj = WriteObj.create!(name: @name, parent_obj_id: @parent.id, obj_class: @obj_class)
+        else
+          @obj = WriteObj.new(name: @name, parent_obj_id: @parent.id, obj_class: @obj_class)
+        end
+      end
+
+      def write_widget_pool
+        resolver = WidgetResolver.new(@obj[:X_widget_pool]||[])
+
+        @id_map = resolver.id_map
+        @widget_path_map = resolver.path_map
+
+        if @widget_pool && !@widget_pool.empty?
+          @widgets = BatchWidgetWriter.new(@obj, @id_map, @widget_pool, @widget_path_map)
+          @widgets.write
+
+          # FIXME: refactor this code
+          if @widgets.pool_changed?
+            # after widget writing this either has new widgets
+            # or some widgets have been removed
+            @new_widget_pool = @widget_path_map.map do |widget_id, path|
+              {title: widget_id, destination_object: path}
+            end
+          end
+        end
+      end
+
+      def store_attributes
+        if @obj.obj_class != @obj_class
+          @obj.obj_class = @obj_class
+          @obj.save!
+          @obj.reload
+        end
+        # TODO: reload into singleton class
+        @obj.send(:reload_attributes)
+        @values.each do |attribute_name, value|
+          virtual_name    = attribute_name.to_sym
+          attribute_name  = real_name = type_register.real_attribute_name(@obj.obj_class, virtual_name)
+          virtual_type    = type_register.attribute_type(@obj.obj_class, virtual_name)
+
+          case virtual_type
+          when :linklist
+            links = (value || []).map do |link|
+              link = link.symbolize_keys
+              new_link = {}
+
+              if link[:url]
+                # handle www.example.com
+                new_link[:url] = "external:#{link[:url]}" unless link[:url] =~ /\A[a-zA-Z][a-zA-Z0-9+.-]:/
+              elsif obj_id = link[:obj_id] 
+                new_link[:url] = WriteObj.find(obj_id).path
+              end
+
+
+              new_link[:url] ||= link[:url] 
+              new_link[:title] = link[:title] if link[:title]
+              new_link[:target] = link[:target] if link[:target]
+              new_link[:url] = "#{new_link[:url]}?#{link[:query]}" if link[:query]
+                new_link[:url] = "#{new_link[:url]}##{link[:fragment]}" if link[:fragment]
+
+              new_link
+            end
+            @obj.set(attribute_name.to_s, links)
+          when :link
+            link = (value || {}).symbolize_keys
+            new_link = {}
+
+            if link[:url]
+              # handle www.example.com
+              new_link[:url] = "external:#{link[:url]}" unless link[:url] =~ /\A[a-zA-Z][a-zA-Z0-9+.-]:/
+            elsif obj_id = link[:obj_id] 
+              new_link[:url] = WriteObj.find(obj_id).path
+            end
+
+
+            new_link[:url] ||= link[:url] 
+            new_link[:title] = link[:title] if link[:title]
+            new_link[:target] = link[:target] if link[:target]
+            new_link[:url] = "#{new_link[:url]}?#{link[:query]}" if link[:query]
+              new_link[:url] = "#{new_link[:url]}##{link[:fragment]}" if link[:fragment]
+
+            new_link
+            if link.empty?
+              @obj.set(attribute_name.to_s, [])
+            else
+              @obj.set(attribute_name.to_s, [new_link])
+            end
+          when :reference
+            obj = WriteObj.find(value) rescue nil
+            if obj
+              @obj.set(attribute_name.to_s, [obj.path])
+            else
+              @obj.set(attribute_name.to_s, [])
+            end
+          when :referencelist
+            ids = value || []
+            if ids.empty?
+              @obj.set(attribute_name.to_s, [])
+            else
+              objects_map = Hash[WriteObj.where(obj_id: ids).map {|o| [o.id, o]}]
+              objects = ids.map {|id| objects_map[id] }.compact
+              @obj.set(attribute_name, objects)
+            end
+          when :widget
+            links = []
+            value = (value || {}).symbolize_keys
+            (value[:list] || []).each do |crap|
+              widget_id = (crap[:widget] || crap['widget']).to_sym
+
+              if (path=@widget_path_map[widget_id]||@widget_path_map[widget_id.to_s])
+                links << {destination_object: path, title: widget_id}
+              else
+                raise Scrivito::ScrivitoError, "Inconsistent widget pool state detected, unable to store widgets"
+              end
+            end
+            @obj.set(attribute_name.to_s, links)
+          when :text, :string, :enum, :multienum, :date
+            @obj.set(attribute_name.to_s, value)
+          when :html
+            converted_links = LinkConverter::ScrivitoToFiona.new(WriteObj, value.to_s).convert
+            @obj.set(attribute_name.to_s, converted_links)
+          when :binary
+            if value.kind_of?(String)
+              # NOTE: this code path has not been tested yet.
+              target = {title: value, destination_object: ReleasedObj.find(value.to_i)}
+              @obj.set(attribute_name.to_s, target)
+            elsif value.kind_of?(File)
+              @obj.set(attribute_name.to_s, upload_file(value))
+            elsif value.kind_of?(ActionDispatch::Http::UploadedFile)
+              @obj.set(attribute_name.to_s, upload_uploaded_file(value))
+            elsif value.nil?
+            else
+              raise Scrivito::ClientError.new("Invalid input for binary field", 422)
+            end
+          else
+            raise Scrivito::ClientError.new("Unknown attribute type: #{virtual_type}", 418)
+          end
+        end
+        @obj.set(:X_widget_pool, @new_widget_pool) if @new_widget_pool
+        @obj.set(:permalink, @permalink) if @permalink
+        @obj.save!
+
+        @obj.edit! unless @obj.really_edited?
+      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
+        {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
+        {title: encoded_id, destination_object: upload}
+      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
+
+      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
+
+        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)
+      end
+    end
+  end
+end

data/lib/fiona7/builder/obj_class_builder.rb

@@ -0,0 +1,111 @@
+require 'fiona7/type_register_mixin'
+
+module Fiona7
+  module Builder
+    class ObjClassBuilder
+      include TypeRegisterMixin
+
+      def initialize(values)
+        @values     = values
+        @attrs_avail= @values.key?(:attributes)
+        @attributes = @values.delete(:attributes) {|_| [] }
+      end
+
+      def build
+        assert_valid
+        add_legacy_attributes
+        mode_dependant_attributes
+        namespace_attributes
+        persist_attributes
+        persist_obj_class
+        update_obj_class
+        load_cm_obj_class
+      end
+
+      def validate
+        unique_obj_class 
+      end
+
+      protected
+      def assert_valid
+        validate || (raise (@error_msg || "Invalid input"))
+      end
+
+      def unique_obj_class
+        ret = @values[:name].present? && !RailsConnector::ObjClass.exists?(obj_class_name: @values[:name])
+        @error_msg = "Expected the ObjClass not to exist: #{@values[:name]}" unless ret
+        ret
+      end
+
+      def add_legacy_attributes
+        type = @values[:type].to_s
+        if type == 'generic' || type == 'image'
+          @attributes << {name: 'blob', type: :binary}
+          @attrs_avail = true
+        end
+        if type.present?
+          # legacy obj class
+          @attributes << {name: 'body', type: :html}
+          @attributes << {name: 'title', type: :html}
+          @attrs_avail = true
+        end
+      end
+
+      def mode_dependant_attributes
+        if Fiona7.mode == :standalone
+          # nop
+        elsif Fiona7.mode == :legacy
+          # in legacy mode body and title are always included
+          # and are mapped to built-in attributes, hence no 
+          # need for custom attributes
+          @attributes.delete_if {|a| n = a[:name].to_s ; n == 'body' || n == 'title' }
+        else
+          raise "Invalid Fiona7.mode = #{Fiona7.mode}"
+        end
+
+      end
+
+      def namespace_attributes
+        @attributes.each do |attribute|
+          # s_OBJ_CLASS__ATTRIBUTE_NAME
+          virtual_name = attribute[:name]
+          attribute[:name] = type_register.real_attribute_name(@values[:name], virtual_name)
+          attribute[:real_type] = type_register.map_virtual_to_real_type(attribute[:type])
+        end
+      end
+
+      def persist_attributes
+        @attributes.each do |attribute|
+          if !RailsConnector::Attribute.exists?(attribute_name: attribute[:name])
+            raw_attribute = Reactor::Cm::Attribute.create(attribute[:name].to_s, attribute[:real_type].to_s)
+            raw_attribute.set(:helpText, ::ActiveSupport::JSON.encode({type: attribute[:type]}))
+            raw_attribute.set(:values, attribute[:values]) if attribute[:values]
+            raw_attribute.save!
+          end
+        end
+      end
+
+      def persist_obj_class
+        # WARNING: in the never version no "type" is standard
+        @values[:type] ||= 'publication'
+        @raw_obj_class = Reactor::Cm::ObjClass.create(@values[:name].to_s, @values[:type].to_s)
+        user_attributes = @attributes.map {|a| a[:name] } if @attrs_avail
+        user_attributes ||= []
+        built_in_attributes = ['X_widget_pool']
+        @raw_obj_class.attributes = user_attributes + built_in_attributes
+      end
+
+      def update_obj_class
+        if @values.key?(:is_active)
+          @raw_obj_class.set('isEnabled', @values[:is_active] ? '1' : '0')
+          @raw_obj_class.save!
+        end
+      end
+
+      def load_cm_obj_class
+        RailsConnector::ObjClass.find_by_obj_class_name(@values[:name])
+      end
+    end
+  end
+end
+

data/lib/fiona7/builder/obj_class_updater.rb

@@ -0,0 +1,69 @@
+require 'fiona7/builder/obj_class_builder'
+
+module Fiona7
+  module Builder
+    class ObjClassUpdater < ObjClassBuilder
+      def validate
+        existing_obj_class 
+      end
+
+      def build
+        assert_valid
+        mode_dependant_attributes
+        namespace_attributes
+        persist_attributes
+        persist_obj_class
+        update_obj_class
+        gc_attributes
+        load_cm_obj_class
+      end
+
+      protected
+      def existing_obj_class
+        ret = RailsConnector::ObjClass.exists?(obj_class_name: @values[:name])
+        @error_msg = "Expected #{@values[:name]} to exist" unless ret
+        ret
+      end
+
+      def persist_obj_class
+        @raw_obj_class = Reactor::Cm::ObjClass.get(@values[:name].to_s)
+
+        # DRY: ObjClassBuilder
+        if @attrs_avail
+          user_attributes = @attributes.map {|a| a[:name] }
+          user_attributes ||= []
+        else
+          user_attributes = @raw_obj_class.attributes
+        end
+
+        built_in_attributes = ['X_widget_pool']
+        @raw_obj_class.attributes = user_attributes + built_in_attributes
+      end
+
+      def persist_attributes
+        @attributes.each do |attribute|
+          # TODO: changing attribute types
+          if !RailsConnector::Attribute.exists?(attribute_name: attribute[:name])
+            raw_attribute = Reactor::Cm::Attribute.create(attribute[:name].to_s, attribute[:real_type].to_s)
+            raw_attribute.set(:helpText, ::ActiveSupport::JSON.encode({type: attribute[:type]}))
+            raw_attribute.set(:values, attribute[:values]) if attribute[:values]
+            raw_attribute.save!
+          end
+        end
+      end
+
+      def gc_attributes
+        return if Fiona7.mode == :legacy
+        return unless @attrs_avail
+        pattern = "s_#{@values[:name]}__%"
+
+        fresh   = @attributes.map {|a| a[:name].to_s }
+        stale   = RailsConnector::Attribute.where('attribute_name LIKE ?', pattern).select(:attribute_name).map(&:name)
+
+        (stale - fresh).each do |attribute_name|
+          Reactor::Cm::Attribute.instance(attribute_name.to_s).delete!
+        end
+      end
+    end
+  end
+end