engine2 1.0.4 → 1.0.9

data/lib/engine2/action/array.rb

@@ -0,0 +1,189 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Engine2
+    class ArrayListAction < Action
+        action_type :list
+        include ActionListSupport
+
+        (DefaultFilters ||= {}).merge!(
+            exact: lambda{|entries, name, value, type_info, hash|
+                entries.select{|e|e[name] == value}
+            },
+            string: lambda{|entries, name, value, type_info, hash|
+                if type_info[:type] == :list_select
+                    if type_info[:multiselect]
+                        entries.select{|e|value.include?(e[name].to_s)}
+                    else
+                        entries.select{|e|e[name].to_s == value}
+                    end
+                else
+                    entries.select{|e|e[name].to_s[value]}
+                end
+
+            },
+            boolean: lambda{|*args| DefaultFilters[:exact].(*args)},
+            integer: lambda{|entries, name, value, type_info, hash|
+                if value.is_a? Hash
+                    from, to = value[:from], value[:to]
+                    if from && to
+                        entries.select{|e|e[name] >= from.to_i && e[name] <= to.to_i}
+                    else
+                        entries.select{|e| from ? e[name] >= from.to_i : e[name] <= to.to_i}
+                    end
+                elsif value.is_a? Integer
+                    entries.select{|e|e[name] == value.to_i}
+                else
+                    nil
+                end
+            }
+        )
+
+        def data_source handler
+            []
+        end
+
+        def page_frame handler, entries
+            entries
+        end
+
+        def invoke handler
+            params = handler.params
+            # if params[:initial] || params[:refresh]
+            entries = data_source(handler)
+
+            per_page = lookup(:config, :per_page)
+            page = params[:page].to_i
+            handler.permit page >= 0 && page < 1000
+
+            if order_str = params[:order]
+                order = order_str.to_sym
+                handler.permit lookup(:fields, order, :sort)
+                entries = entries.sort_by{|e|e[order].to_s}
+                entries = entries.reverse if params[:asc] == "true"
+            end
+
+            if search = params[:search]
+                entries = list_search(entries, handler, search)
+            end
+
+            {entries: page_frame(handler, entries[page, per_page]), count: entries.size}
+        end
+
+        def list_search entries, handler, search
+            hash = JSON.parse(search, symbolize_names: true) rescue handler.halt_forbidden
+            model = assets[:model]
+            sfields = lookup(:search_field_list)
+            handler.permit sfields
+            hash.each_pair do |name, value|
+                handler.permit sfields.include?(name)
+
+                type_info = model.find_type_info(name)
+                entries = if filter = (@filters && @filters[name]) || (dynamic? && (static.filters && static.filters[name]))
+                    filter.(handler, entries, hash)
+                elsif filter = DefaultFilters[type_info[:otype]]
+                    filter.(entries, name, value, type_info, hash)
+                else
+                    raise E2Error.new("Filter not found for field '#{name}' in model '#{model}'") unless filter
+                end
+
+                handler.permit entries
+            end
+
+            entries
+        end
+    end
+
+    class ArrayViewAction < Action
+        include ActionViewSupport
+
+        def find_record handler, id
+            node.parent.*.data_source(handler)[id.to_i]
+        end
+    end
+
+    class ArrayFormAction < Action
+    end
+
+    class ArrayCreateAction < ArrayFormAction
+        include ActionCreateSupport
+    end
+
+    class ArrayModifyAction < ArrayFormAction
+        include ActionModifySupport
+
+        def find_record handler, id
+            node.parent.*.data_source(handler)[id.to_i]
+        end
+    end
+
+    class ArrayDeleteAction < Action
+        include ActionDeleteSupport
+
+        def invoke handler
+            handler.permit id = handler.params[:id]
+            node.parent.parent.*.data_source(handler).delete_at(id.to_i)
+        end
+    end
+
+    class ArraySaveAction < Action
+        include ActionApproveSupport
+    end
+
+    class ArrayInsertAction < ArraySaveAction
+        include ActionInsertSupport
+        action_type :approve
+
+        def after_approve handler, record
+            # handler.permit id = record[:id]
+            # ds = node.parent.parent.*.data_source(handler)
+        end
+    end
+
+    class ArrayUpdateAction < ArraySaveAction
+        include ActionUpdateSupport
+        action_type :approve
+
+        def after_approve handler, record
+            handler.permit id = record[:id]
+            node.parent.parent.*.data_source(handler)[id].merge!(record.values)
+        end
+    end
+
+    class Schemes
+        ARRAY_CRUD ||= {array_create: true, array_view: true, array_modify: true, array_delete: true}.freeze
+        ARRAY_VIEW ||= {array_view: true}
+    end
+
+    SCHEMES.instance_eval do
+        define_scheme :array_view do |name = :view|
+            define_node name, ArrayViewAction
+        end
+
+        define_scheme :array_modify do |name = :modify|
+            define_node name, ArrayModifyAction do
+                define_node :approve, ArrayUpdateAction
+            end
+        end
+
+        define_scheme :array_create do |name = :create|
+            define_node name, ArrayCreateAction do
+                define_node :approve, ArrayInsertAction
+            end
+        end
+
+        define_scheme :array_delete do
+            run_scheme :confirm, :delete, ArrayDeleteAction,
+                message: LOCS[:delete_question], title: LOCS[:confirm_delete_title]
+        end
+
+        define_scheme :array do |name, model, options|
+            options ||= Schemes::ARRAY_CRUD
+            define_node name, ArrayListAction, model: model do
+                options.each{|k, v| run_scheme(k) if v}
+
+                define_node_bundle :form, :create, :modify if options[:array_create] && options[:array_modify]
+            end
+        end
+    end
+end

data/lib/engine2/{meta/decode_meta.rb → action/decode.rb}

@@ -1,8 +1,9 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 module Engine2
-    class DecodeMeta < Meta
-        include MetaAPISupport, MetaModelSupport, MetaQuerySupport
+    class DecodeAction < Action
+        include ActionAPISupport, ActionModelSupport, ActionQuerySupport
 
         def decode *fields, &blk
             query select(*fields), &blk
@@ -18,8 +19,8 @@ module Engine2
         end
 
         def post_process
-            if fields = @meta[:fields]
-                fields = fields - static.get[:fields] if dynamic?
+            if fields = @meta[:field_list]
+                fields = fields - static.meta[:field_list] if dynamic?
                 # no decorate here
                 fields.each do |name|
                     type_info = assets[:model].type_info[name] # foreign keys ?
@@ -42,7 +43,7 @@ module Engine2
         end
 
         def post_run
-            query select(*assets[:model].primary_keys) unless @query
+            decode(*assets[:model].primary_keys) unless @query
             @meta[:separator] = '/' unless @meta[:separator]
             super
             @meta[:primary_fields] = assets[:model].primary_keys
@@ -50,48 +51,78 @@ module Engine2
 
     end
 
-    class DecodeListMeta < DecodeMeta
-        meta_type :decode_list
+    class DecodeListAction < DecodeAction
+        action_type :decode_list
 
         def invoke handler
-            {entries: get_query.limit(200).all}
+            {entries: get_query.limit(200).load_all}
+        end
+
+        def order *fields
+            @query = get_query.order *fields
         end
     end
 
-    class TypeAheadMeta < DecodeMeta
-        meta_type :typeahead
+    class TypeAheadAction < DecodeAction
+        action_type :typeahead
 
         def pre_run
             super
-            limit 10
+            @limit = 10
         end
 
         def limit lmt
-            @meta[:limit] = lmt
+            @limit = lmt
+        end
+
+        def get_limit
+            @limit
+        end
+
+        def get_case_insensitive
+            @case_insensitive
+        end
+
+        def case_insensitive
+            @case_insensitive = true
+        end
+
+        def order *fields
+            @query = get_query.order *fields
         end
 
         def invoke handler
+            model = assets[:model]
             if query = handler.params[:query]
-                condition = (@meta[:decode_fields] || @meta[:fields]).map{|f|f.like("%#{query}%")}.inject{|q, f| q | f}
-                {entries: get_query.where(condition).limit(@meta[:limit]).all}
+                fields = @meta[:decode_fields] || static.meta[:decode_fields]
+
+                entries = if query.to_s.empty?
+                    get_query
+                else
+                    table_name = model.table_name
+                    condition = fields.map{|f|table_name.q(f).like("%#{query}%", case_insensitive: @case_insensitive || static.get_case_insensitive)}.reduce{|q, f| q | f}
+                    get_query.where(condition)
+                end.limit(@limit || static.get_limit).load_all
+
+                {entries: entries}
             else
                 handler.permit id = handler.params[:id]
-                record = get_query[Hash[assets[:model].primary_keys.zip(split_keys(id))]]
+                record = get_query.unordered.load Hash[model.primary_keys_qualified.zip(split_keys(id))]
                 # handler.halt_not_found(LOCS[:no_entry]) unless record
                 {entry: record}
             end
         end
     end
 
-    class DecodeEntryMeta < DecodeMeta
-        meta_type :decode_entry
+    class DecodeEntryAction < DecodeAction
+        action_type :decode_entry
 
         def invoke handler
             {entries: invoke_decode(handler, handler.param_to_json(:ids))}
         end
 
         def invoke_decode handler, ids
-            records = get_query.where(ids.map{|keys| Hash[assets[:model].primary_keys.zip(keys)]}.inject{|q, c| q | c}).all
+            records = get_query.where(ids.map{|keys| Hash[assets[:model].primary_keys.zip(keys)]}.reduce{|q, c| q | c}).load_all
             # handler.halt_not_found(LOCS[:no_entry]) if records.empty?
             records
         end
@@ -101,9 +132,9 @@ module Engine2
             if assoc = assets[:assoc]
                 decode = assoc[:model].type_info[assoc[:keys].first][:decode]
 
-                if decode[:search][:multiple] && action.parent.parent.*.is_a?(ListMeta)
-                    action.list.*.menu(:panel_menu).option :choose, icon: :ok #, disabled: "action.selected_size() == 0"
-                    action.list.*.menu(:panel_menu).option :cancel, icon: "remove"
+                if decode[:search][:multiple] && node.parent.parent.*.is_a?(ListAction)
+                    node.list.*.menu(:panel_menu).option :choose, icon: :ok #, disabled: "action.selected_size() == 0"
+                    node.list.*.menu(:panel_menu).option :cancel, icon: "remove"
                 end
             end
         end

data/lib/engine2/action/delete.rb

@@ -0,0 +1,64 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Engine2
+    class DeleteActionBase < Action
+        def invoke_delete_db handler, ids, from_assoc = nil
+            model = assets[:model]
+            model.db.transaction do
+                ids.each do |id|
+                    keys = split_keys(id)
+
+                    model.association_reflections.each do |name, assoc|
+                        ds = case assoc[:type]
+                        when :one_to_one
+                        when :one_to_many
+                            model.db[assoc.associated_class.table_name].where(Hash[assoc[:keys].zip(keys)])
+                        when :many_to_many
+                            model.db[assoc[:join_table]].where(Hash[assoc[:left_keys].zip(keys)])
+                        when :many_to_one
+                            nil
+                        else
+                            unsupported_association assoc[:type]
+                        end
+
+                        if assoc[:delete] == :cascade || from_assoc == assoc.associated_class.table_name
+                            ds.delete
+                        else
+                            raise Sequel::DestroyFailed.new("#{LOCS[:delete_restricted]}: #{name}") unless ds.empty?
+                        end if ds
+                    end
+
+                    rec = model.call(Hash[model.primary_keys.zip(keys)])
+                    rec.destroy(transaction: false)
+                    # model.where(model.primary_keys_hash(keys)).delete # model.dataset[model.primary_key => id].delete
+                end
+            end
+
+            rescue Sequel::NoExistingObject
+                handler.halt_not_found LOCS[:no_entry]
+            rescue Sequel::DestroyFailed => failure
+                handler.halt_forbidden failure.error.to_s
+            {}
+        end
+    end
+
+    class DeleteAction < DeleteActionBase
+        include ActionDeleteSupport
+
+        def invoke handler
+            handler.permit id = handler.params[:id]
+            invoke_delete_db(handler, [id])
+        end
+    end
+
+    class BulkDeleteAction < DeleteActionBase
+        include ActionBulkDeleteSupport
+
+        def invoke handler
+            ids = handler.param_to_json(:ids)
+            handler.permit ids.is_a?(Array)
+            invoke_delete_db(handler, ids)
+        end
+    end
+end

data/lib/engine2/action/form.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module Engine2
+    class FormAction < Action
+        include ActionQuerySupport
+    end
+
+    class CreateAction < FormAction
+        include ActionCreateSupport
+    end
+
+    class ModifyAction < FormAction
+        include ActionModifySupport
+    end
+end

data/lib/engine2/{meta/infra_meta.rb → action/infra.rb}

@@ -1,61 +1,43 @@
 # coding: utf-8
+# frozen_string_literal: true
 
 module Engine2
-    SCHEMES::define_scheme :infra! do |user_info_model = UserInfo|
-        define_action :infra! do
-            self.* do
-                extend MetaPanelSupport, MetaMenuSupport, MetaAPISupport
-                panel_panel_template false
-                panel_template 'infra/index'
-                loc! logged_on: LOCS[:logged_on]
-                menu :menu do
-                    properties group_class: "btn-group-sm"
-                    option :inspect_modal, icon: :wrench, button_loc: false # , show: "action.logged_on"
-
-                    option :logout_form, icon: :"log-out" # , show: "action.logged_on"
-                    option :login_form, icon: :"log-in", disabled: 'action.action_pending()' # , show: "!action.logged_on"
-                end
-
-                @meta_type = :infra
-
-                define_invoke do |handler|
-                    user = handler.user
-                    {user: user ? user.to_hash : nil}
-                end
-            end
+    SCHEMES::define_scheme :login! do |user_info_model = UserInfo|
+        define_node :login_form, LoginFormAction, model: user_info_model do
+            access!{|h|!h.logged_in?}
+            define_node :login, LoginAction
+        end
+    end
 
-            define_action :login_form, LoginFormMeta, model: user_info_model do
-                access!{|h|!h.logged_in?}
-                define_action :login, LoginMeta
-            end
+    SCHEMES::define_scheme :logout! do
+        define_node :logout_form, LogoutFormAction do
+            access! &:logged_in?
+            define_node :logout, LogoutAction
+        end
+    end
 
-            define_action :logout_form, LogoutFormMeta do
-                access! &:logged_in?
-                define_action :logout, LogoutMeta
-            end
+    SCHEMES::define_scheme :infra! do |user_info_model = UserInfo|
+        run_scheme :login!, user_info_model
+        define_node :infra!, InfraAction do
+            run_scheme :login!, user_info_model
+            run_scheme :logout!
 
-            define_action :inspect_modal do
+            define_node :inspect_modal, InspectModalAction do
                 access! &:logged_in?
-                # access!{|h|h.user[:name] == 'admin'}
-                self.* do
-                    extend MetaPanelSupport, MetaMenuSupport
-                    modal_action
-                    panel_template 'infra/inspect'
-                    panel_title "#{:wrench.icon} Inspect"
-                    panel_class "modal-huge"
-                    panel[:backdrop] = true
-                    menu(:panel_menu).option :cancel, icon: "remove"
-                end
-                define_action :inspect do
+                define_node :"inspect_#{SETTINGS[:name]}", WebSocketAction.inherit do
                     self.* do
-                        @meta_type = :inspect
+                        @action_type = :inspect
+
+                        ws_message do |msg, ws|
+                            ws.send! number: msg[:number].to_i + 1
+                        end
                     end
 
-                    define_action_invoke :models do |handler|
+                    define_invoke :models do |handler|
                         {models: Sequel::DATABASES.map{|db| {name: db.uri, models: db.models.keys} }}
                     end
 
-                    define_action_invoke :model_info do |handler|
+                    define_invoke :model_info do |handler|
                         db_name = handler.params[:db]
                         handler.permit db = Sequel::DATABASES.find{|d|d.uri == db_name || (d.uri && d.uri.start_with?(db_name))}
                         handler.permit model = db.models[handler.params[:model].to_sym]
@@ -71,18 +53,22 @@ module Engine2
                             }
                         }
                     end
+
+                    define_invoke :environment do |handler|
+                        {environment: handler.env}
+                    end
                 end
             end
         end
     end
 
     SCHEMES::define_scheme :menu! do
-        define_action :menu!, MenuMeta do
+        define_node :menu!, MenuAction do
         end
     end
 
-    class FileStoreMeta < Meta
-        meta_type :file_store
+    class FileStoreAction < Action
+        action_type :file_store
 
         attr_accessor :model, :field
 
@@ -93,7 +79,7 @@ module Engine2
     end
 
 
-    module BlobSupportMeta
+    module BlobSupportAction
         def serve_blob handler, entry, inf
             handler.permit entry
             handler.attachment entry[inf[:name_field]]
@@ -102,8 +88,8 @@ module Engine2
         end
     end
 
-    class DownloadFileStoreMeta < Meta
-        meta_type :download
+    class DownloadFileStoreAction < Action
+        action_type :download
 
         def invoke handler
             handler.permit id = handler.params[:id]
@@ -111,28 +97,29 @@ module Engine2
             handler.permit entry
             handler.attachment entry[:name]
             handler.content_type (entry[:mime].to_s.empty? ? "application/octet-stream" : entry[:mime])
-            info = action.parent.*.model.type_info[action.parent.*.field]
+            info = node.parent.*.model.type_info[node.parent.*.field]
             open("#{info[:store][:files]}/#{entry[:name]}_#{id}", 'rb'){|f|f.read}
         end
     end
 
-    class UploadFileStoreMeta < Meta
+    class UploadFileStoreAction < Action
         http_method :post
-        meta_type :upload
+        action_type :upload
 
         def invoke handler
             file = handler.params[:file]
             temp = file[:tempfile]
             temp.close
             rackname = File.basename(temp.path)
-            info = action.parent.*.model.type_info[action.parent.*.field]
-            File.rename(temp.path, "#{info[:store][:upload]}/#{rackname}")
+            info = node.parent.*.model.type_info[node.parent.*.field]
+            FileUtils.cp(temp.path, "#{info[:store][:upload]}/#{rackname}") # File.rename(temp.path, "#{info[:store][:upload]}/#{rackname}")
+            FileUtils.rm(temp.path)
             {rackname: rackname}
         end
     end
 
-    class BlobStoreMeta < Meta
-        meta_type :blob_store
+    class BlobStoreAction < Action
+        action_type :blob_store
 
         attr_accessor :model, :field
 
@@ -145,13 +132,13 @@ module Engine2
         end
     end
 
-    class DownloadBlobStoreMeta < Meta
-        include BlobSupportMeta
-        meta_type :download_blob
+    class DownloadBlobStoreAction < Action
+        include BlobSupportAction
+        action_type :download_blob
 
         def invoke handler
-            model = action.parent.*.model
-            inf = model.type_info[action.parent.*.field]
+            model = node.parent.*.model
+            inf = model.type_info[node.parent.*.field]
             handler.permit id = handler.params[:id]
 
             entry = model.naked.select(inf[:bytes_field], inf[:name_field], inf[:mime_field]).where(model.primary_keys_hash(split_keys(id))).first
@@ -159,23 +146,23 @@ module Engine2
         end
     end
 
-    class UploadBlobStoreMeta < Meta
+    class UploadBlobStoreAction < Action
         http_method :post
-        meta_type :upload_blob
+        action_type :upload_blob
 
         def invoke handler
             file = handler.params[:file]
             temp = file[:tempfile]
             temp.close
             rackname = File.basename(temp.path)
-            info = action.parent.*.model.type_info[action.parent.*.field]
+            info = node.parent.*.model.type_info[node.parent.*.field]
             File.rename(temp.path, "#{info[:store][:upload]}/#{rackname}")
             {rackname: rackname}
         end
     end
 
-    class ForeignBlobStoreMeta < Meta
-        meta_type :blob_store
+    class ForeignBlobStoreAction < Action
+        action_type :blob_store
 
         attr_accessor :model, :field
 
@@ -195,13 +182,13 @@ module Engine2
         end
     end
 
-    class DownloadForeignBlobStoreMeta < Meta
-        include BlobSupportMeta
-        meta_type :download_blob
+    class DownloadForeignBlobStoreAction < Action
+        include BlobSupportAction
+        action_type :download_blob
 
         def invoke handler
-            model = action.parent.*.model
-            inf = model.type_info[action.parent.*.field]
+            model = node.parent.*.model
+            inf = model.type_info[node.parent.*.field]
             assoc = model.association_reflections[inf[:assoc_name]]
             blob_model = assoc.associated_class
             handler.permit id = handler.params[:id]
@@ -213,9 +200,9 @@ module Engine2
         end
     end
 
-    # class UploadForeignBlobStoreMeta < Meta
+    # class UploadForeignBlobStoreAction < Action
     #     http_method :post
-    #     meta_type :upload_blob
+    #     action_type :upload_blob
 
     #     def invoke handler
     #         file = handler.params[:file]
@@ -227,17 +214,63 @@ module Engine2
     #     end
     # end
 
-    class LoginFormMeta < Meta
-        include MetaFormSupport
-        meta_type :login_form
+    class InfraAction < Action
+        include ActionPanelSupport, ActionMenuSupport, ActionAPISupport
+        action_type :infra
+
+        def pre_run
+            super
+            panel_panel_template false
+            panel_template 'infra/index'
+            loc! logged_on: LOCS[:logged_on]
+            menu :menu do
+                properties group_class: "btn-group-sm"
+                option :inspect_modal, icon: :wrench, button_loc: false # , show: "action.logged_on"
+            end
+        end
+
+        def invoke handler
+            user = handler.user
+            {user: user ? user.to_hash : nil}
+        end
+
+        def login_meta menu_properties = {show: 'false'}, &blk
+            node.login_form.* &blk
+            menu(:menu).modify_option :login_form, menu_properties
+            node.parent.login_form.* &blk
+        end
+    end
+
+    class InspectModalAction < Action
+        include ActionPanelSupport, ActionMenuSupport
+        action_type :inline
+
+        def pre_run
+            super
+            modal_action
+            panel_template 'infra/inspect'
+            panel_title "#{:wrench.icon} Inspect"
+            panel_class "modal-huge"
+            panel[:backdrop] = true
+            menu(:panel_menu).option :close, icon: "remove"
+        end
+    end
+
+    class LoginFormAction < Action
+        include ActionFormSupport
+        action_type :login_form
 
         def pre_run
             super
             panel_class 'modal-default'
             panel_title LOCS[:login_title]
-            info! :name, loc: LOCS[:user_name]
+            fields! :name, loc: LOCS[:user_name]
             menu(:panel_menu).modify_option :approve, name: :login, icon: :"log-in"
-            @meta[:fields] = [:name, :password]
+            @meta[:field_list] = [:name, :password]
+            parent_action = node.parent.*
+            if parent_action.is_a? ActionMenuSupport
+                parent_action.menu(:menu).option :login_form, icon: :"log-in", disabled: "action.action_pending()"
+            end
         end
 
         def invoke handler
@@ -245,11 +278,11 @@ module Engine2
         end
     end
 
-    class LoginMeta < Meta
-        include MetaApproveSupport
-        meta_type :login
+    class LoginAction < Action
+        include ActionApproveSupport
+        action_type :login
 
-        def validate_record handler, record
+        def validate_record handler, record, parent_id
             super
             record.values[:password] = nil
         end
@@ -263,15 +296,16 @@ module Engine2
         end
     end
 
-    class LogoutFormMeta < Meta
-        include MetaPanelSupport, MetaMenuSupport
-        meta_type :logout_form
+    class LogoutFormAction < Action
+        include ActionPanelSupport, ActionMenuSupport
+        action_type :logout_form
         def pre_run
             super
             panel_template 'scaffold/message'
             panel_title LOCS[:logout_title]
             panel_class 'modal-default'
             @meta[:message] = LOCS[:logout_message]
+            node.parent.*.menu(:menu).option :logout_form, icon: :"log-out" # , show: "action.logged_on"
             menu :panel_menu do
                 option :logout, icon: "ok", loc: LOCS[:ok]
                 option :cancel, icon: "remove"
@@ -279,8 +313,8 @@ module Engine2
         end
     end
 
-    class LogoutMeta < Meta
-        meta_type :logout
+    class LogoutAction < Action
+        action_type :logout
 
         def invoke handler
             handler.session.clear