engine2 1.0.4 → 1.0.5

data/lib/engine2/action/link.rb

@@ -0,0 +1,117 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Engine2
+    class StarToManyLinkAction < Action
+        include ActionModelSupport
+        http_method :post
+        action_type :star_to_many_link
+
+        def pre_run
+            super
+            execute "action.errors || [action.parent().invoke(), action.panel_close()]"
+        end
+
+        def invoke handler
+            json = handler.post_to_json
+            parent = json[:parent_id]
+            ids = json[:ids]
+            handler.permit parent && ids
+            invoke_link_db handler, split_keys(parent), ids
+        end
+
+        def invoke_link_db handler, parent, ids
+            model = assets[:model]
+            assoc = assets[:assoc]
+
+            case assoc[:type]
+            when :one_to_many
+                model.db.transaction do
+                    pk = Hash[assoc[:keys].zip(parent)]
+                    ids.each do |id|
+                        model.where(model.primary_keys_hash(split_keys(id))).update(pk)
+                    end
+                end
+            when :many_to_many
+                p_pk = Hash[assoc[:left_keys].zip(parent)]
+                values = ids.map do |id|
+                    p_pk.merge Hash[assoc[:right_keys].zip(split_keys(id))]
+                end
+                model.db[assoc[:join_table]].multi_insert values
+            else unsupported_association
+            end
+            {}
+        end
+    end
+
+    class StarToManyUnlinkActionBase < Action
+        include ActionModelSupport
+        http_method :delete
+
+        def pre_run
+            super
+            execute "[action.parent().invoke(), action.panel_close()]"
+        end
+
+        def invoke_unlink_db handler, parent, ids
+            model = assets[:model]
+            assoc = assets[:assoc]
+
+            case assoc[:type]
+            when :one_to_many
+                keys = assoc[:keys]
+                if keys.all?{|k|model.db_schema[k][:allow_null] == true}
+                    model.db.transaction do
+                        ids.each do |id|
+                            model.where(model.primary_keys_hash(split_keys(id))).update(Hash[keys.zip([nil])])
+                        end
+                    end
+                else
+                    handler.halt_method_not_allowed LOCS[:"non_nullable"]
+                end
+            when :many_to_many
+                model.db.transaction do
+                    p_pk = Hash[assoc[:left_keys].zip(parent)]
+                    ds = model.db[assoc[:join_table]]
+                    ids.each do |id|
+                        ds.where(p_pk & Hash[assoc[:right_keys].zip(split_keys(id))]).delete
+                    end
+                end
+            else unsupported_association
+            end
+            {}
+        end
+    end
+
+    class StarToManyUnlinkAction < StarToManyUnlinkActionBase
+        action_type :star_to_many_unlink
+
+        def pre_run
+            super
+            node.parent.parent.*.menu(:item_menu).option :confirm_unlink, icon: "minus", show: "action.selected_size() == 0", button_loc: false
+        end
+
+        def invoke handler
+            handler.permit id = handler.params[:id]
+            handler.permit parent = handler.params[:parent_id]
+            invoke_unlink_db handler, split_keys(parent), [id]
+        end
+    end
+
+    class StarToManyBulkUnlinkAction < StarToManyUnlinkActionBase
+        action_type :star_to_many_bulk_unlink
+
+        def pre_run
+            super
+            node.parent.parent.*.select_toggle_menu
+            node.parent.parent.*.menu(:menu).option_after :default_order, :confirm_bulk_unlink, icon: "minus", show: "action.selected_size() > 0", button_loc: false
+        end
+
+        def invoke handler
+            ids = handler.param_to_json(:ids)
+            handler.permit parent = handler.params[:parent_id]
+            handler.permit ids.is_a?(Array)
+            invoke_unlink_db handler, split_keys(parent), ids
+        end
+    end
+end

data/lib/engine2/{meta/list_meta.rb → action/list.rb}

@@ -1,9 +1,10 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 module Engine2
-    class ListMeta < Meta
-        meta_type :list
-        include MetaListSupport, MetaQuerySupport
+    class ListAction < Action
+        action_type :list
+        include ActionListSupport, ActionQuerySupport
 
         (DefaultFilters ||= {}).merge!(
             string: lambda{|query, name, value, type_info, hash|
@@ -48,7 +49,7 @@ module Engine2
                             if keys.length == 1
                                 query.where(name => value)
                             else
-                                query.where(keys.map{|k| hash[k]}.transpose.map{|vals| Hash[keys.zip(vals)]}.inject{|q, c| q | c})
+                                query.where(keys.map{|k| hash[k]}.transpose.map{|vals| Hash[keys.zip(vals)]}.reduce{|q, c| q | c})
                             end
                         when :list_select
                             query.where(name => value) # decode in sql query ?
@@ -63,6 +64,9 @@ module Engine2
                 else
                     nil
                 end
+            },
+            boolean: lambda{|query, name, value, type_info, hash|
+                query.where(name => value)
             }
         )
 
@@ -89,7 +93,7 @@ module Engine2
                 if order_blk = (@orders && @orders[order]) || (dynamic? && (static.orders && static.orders[order]))
                     query = order_blk.(query, handler)
                 else
-                    order = order.qualify(model.table_name) if model.type_info[order]
+                    order = model.table_name.q(order) if model.type_info[order]
                     query = query.order(order)
                 end
 
@@ -113,13 +117,13 @@ module Engine2
             sfields = lookup(:search_fields)
             handler.permit sfields
             hash.each_pair do |name, value|
-                handler.permit sfields.include?(name)
+                handler.permit name = sfields.find{|sf|sf.to_sym == name}
 
                 type_info = get_type_info(name)
                 query = if filter = (@filters && @filters[name]) || (dynamic? && (static.filters && static.filters[name]))
                     filter.(query, hash, handler)
                 elsif filter = DefaultFilters[type_info[:otype]]
-                    name = model.type_info[name] ? name.qualify(model.table_name) : Sequel.expr(name)
+                    name = model.type_info[name] ? model.table_name.q(name) : Sequel.expr(name)
                     filter.(query, name, value, type_info, hash)
                 else
                     raise E2Error.new("Filter not found for field '#{name}' in model '#{model}'") unless filter
@@ -138,8 +142,8 @@ module Engine2
     #
     # Many to One
     #
-    class ManyToOneListMeta < ListMeta
-        meta_type :many_to_one_list
+    class ManyToOneListAction < ListAction
+        action_type :many_to_one_list
 
         def pre_run
             super
@@ -149,29 +153,14 @@ module Engine2
     #
     # * to Many
     #
-    class StarToManyListMeta < ListMeta
-        meta_type :star_to_many_list
+    class StarToManyListAction < ListAction
+        action_type :star_to_many_list
         def pre_run
             super
             menu(:panel_menu).option_at 0, :cancel, icon: "remove"
             panel_title "#{:list.icon} #{LOCS[assets[:assoc][:name]]}"
         end
 
-        # def decode_panel_title handler
-        #     if handler.initial?
-        #         # Hash[assets[:model].primary_keys.zip(split_keys(id))]]
-        #         p action.parent.decode_entry.*.invoke_decode([[handler.params[:parent_id]]])
-        #         panel_title "ADFASDF"
-        #     end
-        # end
-
-        # def post_run
-        #     super
-        #     unless @request_meta_proc
-        #         request{|h| decode_panel_title h}
-        #     end
-        # end
-
         def list_context query, handler
             handler.permit parent = handler.params[:parent_id]
             model = assets[:model]
@@ -180,7 +169,7 @@ module Engine2
             case assoc[:type]
             when :one_to_many
                 keys = assoc[:keys]
-                condition = parent_keys.all?(&:empty?) ? false : Hash[keys.map{|k| k.qualify(model.table_name)}.zip(parent_keys)]
+                condition = parent_keys.all?(&:empty?) ? false : Hash[keys.map{|k| model.table_name.q(k)}.zip(parent_keys)]
                 if handler.params[:negate]
                     query = query.exclude(condition)
                     query = query.or(Hash[keys.zip([nil])]) if keys.all?{|k|model.db_schema[k][:allow_null] == true} # type_info[:required] ?
@@ -191,35 +180,50 @@ module Engine2
             when :many_to_many
                 q_pk = model.primary_keys_qualified
                 j_table = assoc[:join_table]
-                l_keys = assoc[:left_keys].map{|k| k.qualify(j_table)}
-                r_keys = assoc[:right_keys].map{|k| k.qualify(j_table)}
+                l_keys = assoc[:left_keys].map{|k| j_table.q(k)}
+                r_keys = assoc[:right_keys].map{|k| j_table.q(k)}
                 r_keys_vals = Hash[r_keys.zip(q_pk)]
                 l_keys_vals = parent_keys.all?(&:empty?) ? false : Hash[l_keys.zip(parent_keys)]
 
                 if handler.params[:negate]
-                    query.exclude(model.db[j_table].select(nil).where(r_keys_vals, l_keys_vals).exists)
+                    query.exclude(model.db[j_table].select(nil).where(r_keys_vals & l_keys_vals).exists)
                 else
                     # query.qualify.join(j_table, [r_keys_vals, l_keys_vals])
-                    query.qualify.left_join(j_table, r_keys_vals).filter(l_keys_vals)
+                    if joins = query.opts[:join] and joins.find{|j|j.table == j_table}
+                        query
+                    else
+                        query.qualify.left_join(j_table, r_keys_vals)
+                    end.filter(l_keys_vals)
                 end
             else unsupported_association
             end
         end
+
+        def post_run
+            super
+            request do |h|
+                if h.initial? && nd = node.parent.nodes[:decode_entry]
+                    action = nd.*
+                    rec = action.invoke_decode(h, [[h.params[:parent_id]]]).first
+                    panel_title "#{static.panel[:title]} - #{rec}"
+                end
+            end
+        end
     end
 
-    class StarToManyLinkListMeta < StarToManyListMeta
-        meta_type :star_to_many_link_list
+    class StarToManyLinkListAction < StarToManyListAction
+        action_type :star_to_many_link_list
         def pre_run
             super
             panel_title LOCS[:link_title]
             menu(:panel_menu).option_at 0, :link, icon: "ok", enabled: "action.selected_size() > 0"
-            action.parent.*.menu(:menu).option_at 0, :link_list, icon: "paperclip", button_loc: false
+            node.parent.*.menu(:menu).option_at 0, :link_list, icon: "paperclip", button_loc: false
         end
     end
 
     # *_to_many_field
-    class StarToManyFieldMeta < StarToManyListMeta
-        meta_type :star_to_many_field
+    class StarToManyFieldAction < StarToManyListAction
+        action_type :star_to_many_field
 
         def pre_run
             super
@@ -228,53 +232,48 @@ module Engine2
         end
 
         def list_context query, handler
-            unlinked = handler.param_to_json(:unlinked)
-            linked = handler.param_to_json(:linked)
-            query = super(query, handler)
+            changes = handler.param_to_json(:changes)
             model = assets[:model]
+            unlinked = changes[:unlink].to_a + changes[:delete].to_a + changes[:modify].to_a.map{|m|Sequel::join_keys(model.primary_keys.map{|k|m[k]})}
+            linked = changes[:link]
+            query = super(query, handler)
+
             pks = model.primary_keys_qualified
 
             if handler.params[:negate]
-                query = unlinked.map{|ln| pks.zip(split_keys(ln))}.inject(query){|q, c| q.or c}
-                # query = query.or *unlinked.map{|unl| Hash[model.primary_keys.zip(split_keys(unl))]}.inject{|q, c| q | c}
-                query = query.where *linked.map{|ln| pks.zip(split_keys(ln)).sql_negate}
-
+                query = unlinked.reduce(query){|q, unl|q.or pks.zip(split_keys(unl))}
+                query = linked.reduce(query){|q, ln|q.where(pks.zip(split_keys(ln)).sql_negate)}
             else
-                query = query.where *unlinked.map{|unl| pks.zip(split_keys(unl)).sql_negate}
-                # query = query.or *linked.map{|ln| model.primary_keys.zip(split_keys(ln))}
-                # query = query.or *linked.map{|ln| Hash[model.primary_keys.zip(split_keys(ln))]}.inject{|q, c| q | c}
-                case assets[:assoc][:type]
+                query = unlinked.reduce(query){|q, unl|q.where(pks.zip(split_keys(unl)).sql_negate)}
+                query = case assets[:assoc][:type]
                 when :one_to_many
-                    query = linked.map{|ln| pks.zip(split_keys(ln))}.inject(query){|q, c| q.or c}
+                    linked.reduce(query){|q, ln|q.or pks.zip(split_keys(ln))}
                 when :many_to_many
-                    query = linked.map{|ln| pks.zip(split_keys(ln))}.inject(query){|q, c| q.or c}.distinct
+                    linked.reduce(query){|q, ln|q.or pks.zip(split_keys(ln))}.distinct
                 else unsupported_association
                 end unless linked.empty?
             end
 
-            query
-        end
-    end
-
-    class StarToManyFieldUnlinkMeta < Meta
-        meta_type :star_to_many_field_unlink
+            added = changes[:create].to_a + changes[:modify].to_a
+            cols = get_query.columns
+            query = added.reduce query do |q, a|
+                q.union(model.db.select(*cols.map{|c|a[c]}), all: true, alias: model.table_name)
+            end
 
-        def pre_run
-            super
-            action.parent.parent.*.menu(:item_menu).option :confirm_unlink, icon: "minus", show: "action.selected_size() == 0", button_loc: false
+            query
         end
     end
 
-    class StarToManyFieldLinkListMeta < StarToManyFieldMeta
-        meta_type :star_to_many_field_link_list
+    class StarToManyFieldLinkListAction < StarToManyFieldAction
+        action_type :star_to_many_field_link_list
 
         def pre_run
             super
             modal_action true
-            panel_panel_template 'scaffold/list'
+            panel_panel_template nil
             panel_title LOCS[:link_title]
             menu(:panel_menu).option_at 0, :link, icon: "ok", enabled: "action.selected_size() > 0"
-            action.parent.*.menu(:menu).option_at 0, :link_list, icon: "paperclip", button_loc: false
+            node.parent.*.menu(:menu).option_at 0, :link_list, icon: "paperclip", button_loc: false
         end
     end
 end

data/lib/engine2/action/save.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Engine2
+
+    class SaveAction < Action
+        include ActionSaveSupport
+    end
+
+    class InsertAction < SaveAction
+        include ActionInsertSupport
+        action_type :approve
+    end
+
+    class UpdateAction < SaveAction
+        include ActionUpdateSupport
+        action_type :approve
+    end
+
+    class StarToManyFieldInsertAction < InsertAction
+        self.validate_only = true
+        action_type :star_to_many_field_approve
+    end
+
+    class StarToManyFieldUpdateAction < UpdateAction
+        self.validate_only = true
+        action_type :star_to_many_field_approve
+    end
+
+end

data/lib/engine2/action/view.rb

@@ -0,0 +1,8 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Engine2
+    class ViewAction < Action
+        include ActionViewSupport, ActionQuerySupport
+    end
+end

data/lib/engine2/action_node.rb

@@ -0,0 +1,221 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Engine2
+
+    class ActionNode < BasicObject
+        ACCESS_FORBIDDEN ||= ->h{false}
+        attr_reader :parent, :name, :number, :nodes, :recheck_access
+        attr_reader :meta_proc, :access_block
+
+        class << self
+            attr_accessor :count
+        end
+
+        def initialize parent, name, action_class, assets
+            ActionNode.count += 1
+            @number = ActionNode.count
+            @parent = parent
+            @name = name
+            @action = action_class.new(self, assets)
+            @nodes = {}
+        end
+
+        def * &blk
+            @meta_proc = @meta_proc ? @meta_proc.chain(&blk) : blk if blk
+            @action
+        end
+
+        alias :action :*
+
+        def access! &blk
+            ::Kernel.raise E2Error.new("Access for node #{name} already defined") if @access_block
+            @access_block = blk
+        end
+
+        def access_forbidden!
+            access! &ACCESS_FORBIDDEN
+        end
+
+        def check_access! handler
+        	!@access_block || @access_block.(handler)
+        end
+
+        def run_scheme name, *args, &blk
+            result = instance_exec(*args, &SCHEMES[name])
+            result.instance_eval(&blk) if blk
+            result
+        end
+
+        def define_node name, action_class = InlineAction.inherit, assets = {}, &blk
+            ::Kernel.raise E2Error.new("ActionNode #{name} already defined") if @nodes[name]
+            node = @nodes[name] = ActionNode.new(self, name, action_class, assets)
+            node.*.pre_run
+            define_singleton_method! name do |&ablk| # forbidden list
+                node.instance_eval(&ablk) if ablk
+                node
+            end
+            node.instance_eval(&blk) if blk
+            node.*.node_defined
+            node
+        end
+
+        def define_action name, action_class = InlineAction.inherit, assets = {}, &blk
+            define_node name, action_class, assets do
+                self.* &blk
+            end
+        end
+
+        def define_invoke name, action_class = InlineAction.inherit, assets = {}, &blk
+            define_node name, action_class, assets do
+                self.*.define_invoke &blk
+            end
+        end
+
+        def define_node_bundle name, *nodes
+            define_singleton_method!(name) do |&blk|
+                if blk
+                    nodes.each{|a|__send__(a, &blk)} # if @nodes[node] ?
+                else
+                    ActionNodeBundle.new(self, nodes)
+                end
+            end
+        end
+
+        def define_singleton_method! name, &blk
+            class << self;self;end.instance_eval do # __realclass__
+                define_method name, &blk
+            end
+        end
+
+        def [] name
+            @nodes[name]
+        end
+
+        def nodes_info handler
+            info = nodes.reduce({}) do |h, (name, a)|
+                action = a.*
+                act = {
+                    action_type: action.action_type,
+                    method: action.http_method,
+                    number: a.number,
+                    terminal: a.nodes.empty?,
+                    meta: !action.meta.empty?
+                }
+
+                act[:access] = true if !recheck_access && a.check_access!(handler)
+                act[:recheck_access] = true if a.recheck_access
+
+                if Handler::development?
+                    act[:action_class] = action.class
+                    act[:access_block] = a.access_block if a.access_block
+                    act[:model] = action.assets[:model]
+                end
+
+                h[name] = act
+                h
+            end
+
+            info.first[1][:default] = true unless nodes.empty?
+            info
+        end
+
+        def access_info handler
+            @nodes.reduce({}) do |h, (name, a)|
+                h[name] = a.check_access!(handler)
+                h
+            end
+        end
+
+        def recheck_access!
+            @recheck_access = true
+        end
+
+        def each_node &blk
+            # no self
+            @nodes.each_pair do |n, a|
+                a.each_node(&blk) if yield a
+            end
+        end
+
+        def to_a_rec root = true, result = [], &blk # optimize
+            if root && (yield self)
+                result << self
+                @nodes.each_pair do |n, a|
+                    if yield a
+                        result << a
+                        a.to_a_rec(false, result, &blk)
+                    end
+                end
+            end
+            result
+        end
+
+        def inspect
+            "ActionNode: #{@name}, action: #{@action.class}, action_type: #{@action.action_type}"
+        end
+
+        def setup_node_tree
+            time = ::Time.now
+
+            model_nodes = {}
+            each_node do |node|
+                if model = node.*.assets[:model]
+                    model_name = model.name.to_sym
+                    model.synchronize_type_info
+                    model_nodes[model_name] = node.to_a_rec{|a| !a.*.assets[:assoc]}
+                    node.run_scheme(model_name) if SCHEMES[model_name, false]
+                    false
+                else
+                    true
+                end
+            end
+
+            thefts = 0
+            each_node do |node|
+                action = node.*
+                model = action.assets[:model]
+                assoc = action.assets[:assoc]
+                if model && assoc
+                    if source_nodes = model_nodes[model.name.to_sym]
+                        source_node = source_nodes.select{|sa| sa.meta_proc && sa.*.class >= action.class}
+                        # source_node = source_nodes.select{|sa| sa.meta_proc && action.class <= sa.*.class}
+                        unless source_node.empty?
+                            raise E2Error.new("Multiple action candidates for #{node.inspect} found in '#{source_node.inspect}'") if source_node.size > 1
+                            # puts "#{node.inspect} => #{source_node.inspect}\n"
+                            action.instance_eval(&source_node.first.meta_proc)
+                            thefts += 1
+                        end
+                    end
+                end
+
+                action.instance_eval(&node.meta_proc) if node.meta_proc
+                true
+            end
+
+            each_node do |node|
+                node.*.post_run
+                node.*.freeze_action
+                true
+            end
+
+            ::Kernel::puts "ACTION NODES: #{ActionNode.count}, Time: #{::Time.now - time}, Thefts: #{thefts}"
+        end
+
+        def p *args
+            ::Kernel::p *args
+        end
+    end
+
+
+    class ActionNodeBundle
+        def initialize node, node_names
+            @node = node
+            @node_names = node_names
+        end
+
+        def method_missing name, *args, &blk
+            @node_names.each{|an| @node[an].__send__(name, *args, &blk)}
+        end
+    end
+end