engine2 1.0.0

data/lib/engine2/meta/decode_meta.rb

@@ -0,0 +1,110 @@
+# coding: utf-8
+
+module Engine2
+    class DecodeMeta < Meta
+        include MetaAPISupport, MetaModelSupport, MetaQuerySupport
+
+        def decode *fields, &blk
+            query select(*fields), &blk
+            @meta[:decode_fields] = fields
+        end
+
+        def separator sep
+            @meta[:separator] = sep
+        end
+
+        def show_max_selected max
+            @meta[:show_max_selected] = max
+        end
+
+        def post_process
+            if fields = @meta[:fields]
+                fields = fields - static.get[:fields] if dynamic?
+                # no decorate here
+                fields.each do |name|
+                    type_info = assets[:model].type_info[name] # foreign keys ?
+                    proc = ListRendererPostProcessors[type_info[:type]] # like... checkboxes, list_selects
+                    proc.(self, name, type_info) if proc
+                end
+            end
+            # no super
+        end
+
+        def pre_run
+            super
+            if assoc = assets[:assoc]
+                decode = assoc[:model].type_info[assoc[:keys].first][:decode]
+                if decode[:search][:multiple]
+                    show_max_selected 3
+                    @meta[:decode_selected] = LOCS[:decode_selected]
+                end
+            end
+        end
+
+        def post_run
+            query select(*assets[:model].primary_keys) unless @query
+            @meta[:separator] = '/' unless @meta[:separator]
+            super
+            @meta[:primary_fields] = assets[:model].primary_keys
+        end
+
+    end
+
+    class DecodeListMeta < DecodeMeta
+        meta_type :decode_list
+
+        def invoke handler
+            {entries: get_query.limit(200).all}
+        end
+    end
+
+    class TypeAheadMeta < DecodeMeta
+        meta_type :typeahead
+
+        def pre_run
+            super
+            limit 10
+        end
+
+        def limit lmt
+            @meta[:limit] = lmt
+        end
+
+        def invoke handler
+            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}
+            else
+                handler.permit id = handler.params[:id]
+                record = get_query[Hash[assets[:model].primary_keys.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
+
+        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
+            # handler.halt_not_found(LOCS[:no_entry]) if records.empty?
+            records
+        end
+
+        def post_run
+            super
+            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_at 0, :choose, icon: :ok # , disabled: "action.selected_size() == 0"
+                end
+            end
+        end
+    end
+end

data/lib/engine2/meta/delete_meta.rb

@@ -0,0 +1,73 @@
+# coding: utf-8
+
+module Engine2
+    class DeleteMetaBase < Meta
+        include MetaModelSupport
+
+        def invoke_delete_db handler, ids
+            begin
+                model = assets[:model]
+                model.db.transaction do
+                    ids.each do |id|
+                        keys = split_keys(id)
+                        restrict = model.association_reflections.select do |name, rel|
+                            case rel[:type]
+                            when :one_to_many
+                                !model.db[name].where(Hash[rel[:keys].zip(keys)]).empty?
+                            when :many_to_many
+                                !model.db[rel[:join_table]].where(Hash[rel[:left_keys].zip(keys)]).empty?
+                            when :many_to_one
+                            when :one_to_one
+                            else
+                                unsupported_association rel[:type]
+                            end
+                        end
+                        raise Sequel::DestroyFailed.new("Blokujące relacje: #{restrict.map{|name, rel| name}.join(', ')}" ) unless restrict.empty?
+
+                        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
+
+    end
+
+    class DeleteMeta < DeleteMetaBase
+        http_method :delete
+        meta_type :delete
+
+        def pre_run
+            super
+            action.parent.parent.*.menu(:item_menu).option :confirm_delete, icon: "trash", show: "action.selected_size() == 0", button_loc: false
+        end
+
+        def invoke handler
+            handler.permit id = handler.params[:id]
+            invoke_delete_db(handler, [id])
+        end
+    end
+
+    class BulkDeleteMeta < DeleteMetaBase
+        http_method :delete
+        meta_type :bulk_delete
+
+        def pre_run
+            super
+            action.parent.parent.*.menu(:menu).option_after :default_order, :confirm_bulk_delete, icon: "trash", show: "action.selected_size() > 0"
+        end
+
+        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/meta/form_meta.rb

@@ -0,0 +1,144 @@
+# coding: utf-8
+
+module Engine2
+    class FormMeta < Meta
+        include MetaAPISupport, MetaModelSupport, MetaQuerySupport, MetaTabSupport, MetaPanelSupport, MetaMenuSupport, MetaAngularSupport, MetaOnChangeSupport
+
+        def field_template template
+            panel[:field_template] = template
+        end
+
+        def pre_run
+            super
+            panel_template 'scaffold/form'
+            field_template 'scaffold/fields'
+            panel_class 'modal-large'
+
+            menu :panel_menu do
+                option :approve, icon: "ok", disabled: 'action.action_pending' # text: true,
+                option :cancel, icon: "remove" # text: true,
+            end
+            # modal_action false
+        end
+
+        def record handler, record
+        end
+
+        def post_process
+            if fields = @meta[:fields]
+                fields = fields - static.get[:fields] if dynamic?
+
+                decorate(fields)
+
+                fields.each do |name|
+                    # type_info = model.type_info.fetch(name)
+                    type_info = get_type_info(name)
+
+                    info[name][:render] ||= begin
+                        renderer = DefaultFormRenderers[type_info[:type]] # .merge(default: true)
+                        raise E2Error.new("No form renderer found for field '#{type_info[:name]}' of type '#{type_info[:type]}'") unless renderer
+                        renderer.(self, type_info)
+                    end
+
+                    proc = FormRendererPostProcessors[type_info[:type]]
+                    proc.(self, name, type_info) if proc
+                end
+
+                assoc = assets[:assoc]
+                if assoc && assoc[:type] == :one_to_many
+                    # fields.select{|f| assoc[:keys].include? f}.each do |key|
+                    #     # hide_fields(key) if self[:info, key, :hidden] == nil
+                    #     info! key, disabled: true
+                    # end
+                    assoc[:keys].each do |key|
+                        info! key, disabled: true if fields.include? key
+                    end
+                end
+            end
+
+            super
+        end
+
+        def post_run
+            super
+            @meta[:primary_fields] = assets[:model].primary_keys
+        end
+
+        def template
+            Templates
+        end
+
+        def hr_after field, message = '-'
+            info! field, hr: message
+        end
+    end
+
+    class CreateMeta < FormMeta
+        meta_type :create
+
+        def pre_run
+            super
+            panel_title LOCS[:create_title]
+            action.parent.*.menu(:menu).option_at 0, action.name, icon: "plus-sign", button_loc: false
+
+            hide_pk unless assets[:model].natural_key
+        end
+
+        def record handler, record
+            create_record(handler, record)
+        end
+
+        def create_record handler, record
+        end
+
+        def invoke handler
+            record = {}
+            if assoc = assets[:assoc]
+                case assoc[:type]
+                when :one_to_many
+                    handler.permit parent = handler.params[:parent_id]
+                    assoc[:keys].zip(split_keys(parent)).each{|key, val| record[key] = val}
+                end
+            end
+            static.record(handler, record)
+            {record: record, new: true}
+        end
+    end
+
+    class ModifyMeta < FormMeta
+        meta_type :modify
+
+        def pre_run
+            super
+            panel_title LOCS[:modify_title]
+            action.parent.*.menu(:item_menu).option action.name, icon: "pencil", button_loc: false
+        end
+
+        def record handler, record
+            modify_record(handler, record)
+        end
+
+        def modify_record handler, record
+        end
+
+        def invoke handler
+            handler.permit id = handler.params[:id]
+            record = get_query[assets[:model].primary_keys_hash_qualified(split_keys(id))]
+
+            if record
+                static.record(handler, record)
+                {record: record}
+            else
+                handler.halt_not_found LOCS[:no_entry]
+            end
+        end
+
+        def post_run
+            super
+            assets[:model].primary_keys.each do |key| # pre_run ?
+                info! key, disabled: true
+            end
+        end
+    end
+
+end

data/lib/engine2/meta/infra_meta.rb

@@ -0,0 +1,292 @@
+# coding: utf-8
+
+module Engine2
+    SCHEMES::define_scheme :infra! do |user_info_model = UserInfo|
+        define_action :infra! do
+            self.* do
+                extend MetaPanelSupport, MetaMenuSupport
+                panel_panel_template false
+                panel_template 'infra/index'
+                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" # , show: "!action.logged_on"
+                end
+
+                @meta_type = :infra
+
+                def invoke handler
+                    user = handler.user
+                    {user: user ? user.to_hash : nil}
+                end
+            end
+
+            define_action :login_form, LoginFormMeta, model: user_info_model do
+                access!{|h|!h.logged_in?}
+                define_action :login, LoginMeta
+            end
+
+            define_action :logout_form, LogoutFormMeta do
+                access! &:logged_in?
+                define_action :logout, LogoutMeta
+            end
+
+            define_action :inspect_modal do
+                access! &:logged_in?
+                # access!{|h|h.user[:name] == 'admin'}
+                self.* do
+                    extend MetaPanelSupport, MetaMenuSupport
+                    modal_action
+                    panel_template 'infra/inspect'
+                    panel_title "Inspect"
+                    panel_class "modal-huge"
+                    menu(:panel_menu).option :cancel, icon: "remove"
+
+                    # def invoke handler;{};end
+                end
+                define_action :inspect do
+                    self.* do
+                        @meta_type = :inspect
+                    end
+
+                    define_action :models do
+                        def (self.*).invoke handler
+                            {models: Sequel::DATABASES.map{|db| {name: db.uri, models: db.models.keys} }}
+                        end
+                    end
+
+                    define_action :model_info do
+                        def (self.*).invoke 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]
+                            {
+                                model: {
+                                    info: {
+                                        name: model.to_s,
+                                        table: model.table_name
+                                    },
+                                    assoc: model.association_reflections,
+                                    schema: model.db_schema,
+                                    type_info: model.type_info
+                                }
+                            }
+                        end
+                    end
+                end
+            end
+        end
+    end
+
+    SCHEMES::define_scheme :menu! do
+        define_action :menu!, MenuMeta do
+        end
+    end
+
+    class FileStoreMeta < Meta
+        meta_type :file_store
+
+        attr_accessor :model, :field
+
+        def invoke handler
+            handler.permit owner = handler.params[:owner]
+            {files: E2Files.db[:files].select(:id, :name, :mime, :uploaded).where(owner: owner, model: model.name.to_s, field: field.to_s).all}
+        end
+    end
+
+
+    module BlobSupportMeta
+        def serve_blob handler, entry, inf
+            handler.permit entry
+            handler.attachment entry[inf[:name_field]]
+            handler.content_type (entry[inf[:mime_field]].to_s.empty? ? "application/octet-stream" : entry[inf[:mime_field]])
+            entry[inf[:bytes_field]].getBinaryStream().to_io.read
+        end
+    end
+
+    class DownloadFileStoreMeta < Meta
+        meta_type :download
+
+        def invoke handler
+            handler.permit id = handler.params[:id]
+            entry = E2Files.db[:files].select(:name, :mime)[id: id]
+            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]
+            open("#{info[:store][:files]}/#{entry[:name]}_#{id}", 'rb'){|f|f.read}
+        end
+    end
+
+    class UploadFileStoreMeta < Meta
+        http_method :post
+        meta_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}")
+            {rackname: rackname}
+        end
+    end
+
+    class BlobStoreMeta < Meta
+        meta_type :blob_store
+
+        attr_accessor :model, :field
+
+        def invoke handler
+            handler.permit id = handler.params[:owner]
+            inf = model.type_info[field]
+            result = model.naked.select(inf[:name_field], Sequel.char_length(inf[:bytes_field]).as(:length)).where(model.primary_keys_hash(split_keys(id))).first
+            handler.permit result
+            {file_name: result[inf[:name_field]], blob_length: result[:length]}
+        end
+    end
+
+    class DownloadBlobStoreMeta < Meta
+        include BlobSupportMeta
+        meta_type :download_blob
+
+        def invoke handler
+            model = action.parent.*.model
+            inf = model.type_info[action.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
+            serve_blob(handler, entry, inf)
+        end
+    end
+
+    class UploadBlobStoreMeta < Meta
+        http_method :post
+        meta_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]
+            File.rename(temp.path, "#{info[:store][:upload]}/#{rackname}")
+            {rackname: rackname}
+        end
+    end
+
+    class ForeignBlobStoreMeta < Meta
+        meta_type :blob_store
+
+        attr_accessor :model, :field
+
+        def invoke handler
+            handler.permit id = handler.params[:owner]
+
+            inf = model.type_info[field]
+            assoc = model.association_reflections[inf[:assoc_name]]
+            blob_model = Object.const_get(assoc[:class_name])
+
+            rec = model.naked.select(assoc[:key]).where(model.primary_keys_hash(split_keys(id))).first
+            handler.permit rec
+            result = blob_model.naked.select(inf[:name_field], Sequel.char_length(inf[:bytes_field]).as(:length)).where(blob_model.primary_key => rec[assoc[:key]]).first
+
+            # handler.permit result
+            {file_name: result ? result[inf[:name_field]] : :empty, blob_length: result ? result[:length] : 0}
+        end
+    end
+
+    class DownloadForeignBlobStoreMeta < Meta
+        include BlobSupportMeta
+        meta_type :download_blob
+
+        def invoke handler
+            model = action.parent.*.model
+            inf = model.type_info[action.parent.*.field]
+            assoc = model.association_reflections[inf[:assoc_name]]
+            blob_model = Object.const_get(assoc[:class_name])
+            handler.permit id = handler.params[:id]
+            rec = model.naked.select(assoc[:key]).where(model.primary_keys_hash(split_keys(id))).first
+            handler.permit rec
+
+            entry = blob_model.naked.select(inf[:bytes_field], inf[:name_field], inf[:mime_field]).where(blob_model.primary_key => rec[assoc[:key]]).first
+            serve_blob(handler, entry, inf)
+        end
+    end
+
+    # class UploadForeignBlobStoreMeta < Meta
+    #     http_method :post
+    #     meta_type :upload_blob
+
+    #     def invoke handler
+    #         file = handler.params[:file]
+    #         temp = file[:tempfile]
+    #         temp.close
+    #         rackname = File.basename(temp.path)
+    #         File.rename(temp.path, "#{UPLOAD_DIR}/#{rackname}")
+    #         {rackname: rackname}
+    #     end
+    # end
+
+    class LoginFormMeta < FormMeta
+        meta_type :login_form
+
+        def pre_run
+            super
+            panel_class 'modal-default'
+            panel_title LOCS[:login_title]
+            info! :name, loc: LOCS[:user_name]
+            menu(:panel_menu).modify_option :approve, name: :login, icon: :"log-in"
+        end
+
+        def invoke handler
+            {record: {}, new: true}
+        end
+    end
+
+    class LoginMeta < Meta
+        include MetaApproveSupport
+        http_method :post
+        meta_type :login
+
+        def after_approve handler, record
+            handler.session[:user] = record
+        end
+
+        def record handler, record
+            {errors: nil, user: handler.user.to_hash}
+        end
+    end
+
+    class LogoutFormMeta < Meta
+        include MetaPanelSupport, MetaMenuSupport
+        meta_type :logout_form
+        def pre_run
+            super
+            panel_template 'scaffold/message'
+            panel_title LOCS[:logout_title]
+            panel_class 'modal-default'
+            menu :panel_menu do
+                option :logout, icon: "ok", loc: LOCS[:ok]
+                option :cancel, icon: "remove"
+            end
+        end
+
+        def invoke handler
+            {message: LOCS[:logout_message]}
+        end
+    end
+
+    class LogoutMeta < Meta
+        meta_type :logout
+
+        def invoke handler
+            handler.session.clear
+            # handler.session[:logged_in] = false
+            {}
+        end
+    end
+end