engine2 1.0.0

data/lib/engine2/meta/link_meta.rb

@@ -0,0 +1,133 @@
+# coding: utf-8
+
+module Engine2
+    class StarToManyLinkMeta < Meta
+        include MetaModelSupport
+        http_method :post
+        meta_type :star_to_many_link
+
+        def invoke handler
+            json = handler.post_to_json
+            parent = json[:parent_id]
+            ids = json[:ids]
+            handler.permit parent && ids
+            model = assets[:model]
+            assoc = assets[:assoc]
+            case assoc[:type]
+            when :one_to_many
+                model.db.transaction do
+                    self.class.one_to_many_link_db model, assoc, split_keys(parent), ids
+                end
+                {}
+            when :many_to_many
+                self.class.many_to_many_link_db model, assoc, split_keys(parent), ids
+                {}
+            else unsupported_association
+            end
+        end
+
+        def self.one_to_many_link_db model, assoc, parent, ids
+            pk = Hash[assoc[:keys].zip(parent)]
+            ids.each do |id|
+                model.where(model.primary_keys_hash(Sequel::split_keys(id))).update(pk)
+            end
+        end
+
+        def self.many_to_many_link_db model, assoc, parent, ids
+            p_pk = Hash[assoc[:left_keys].zip(parent)]
+            values = ids.map do |id|
+                p_pk.merge Hash[assoc[:right_keys].zip(Sequel::split_keys(id))]
+            end
+            model.db[assoc[:join_table]].multi_insert values
+        end
+    end
+
+    class StarToManyUnlinkMetaBase < Meta
+        include MetaModelSupport
+        http_method :delete
+
+        def one_to_many_unlink_db handler, ids
+            model = assets[:model]
+            assoc = assets[:assoc]
+            keys = assoc[:keys]
+            if keys.all?{|k|model.db_schema[k][:allow_null] == true}
+                model.db.transaction do
+                    self.class.one_to_many_unlink_db model, assoc, ids
+                end
+                {}
+            else
+                handler.halt_method_not_allowed LOCS[:"non_nullable"]
+            end
+        end
+
+        def self.one_to_many_unlink_db model, assoc, ids
+            keys = assoc[:keys]
+            ids.each do |id|
+                model.where(model.primary_keys_hash(Sequel::split_keys(id))).update(Hash[keys.zip([nil])])
+            end
+        end
+
+        def many_to_many_unlink_db parent, ids
+            model = assets[:model]
+            assoc = assets[:assoc]
+
+            model.db.transaction do
+                self.class.many_to_many_unlink_db model, assoc, Sequel::split_keys(parent), ids
+            end
+            {}
+        end
+
+        def self.many_to_many_unlink_db model, assoc, parent, ids
+            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(Sequel::split_keys(id))]).delete
+            end
+        end
+    end
+
+    class StarToManyUnlinkMeta < StarToManyUnlinkMetaBase
+        meta_type :star_to_many_unlink
+
+        def pre_run
+            super
+            action.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]
+            assoc = assets[:assoc]
+            case assoc[:type]
+            when :one_to_many
+                one_to_many_unlink_db(handler, [id])
+            when :many_to_many
+                handler.permit parent = handler.params[:parent_id]
+                many_to_many_unlink_db(parent, [id])
+            else unsupported_association
+            end
+        end
+    end
+
+    class StarToManyBulkUnlinkMeta < StarToManyUnlinkMetaBase
+        meta_type :star_to_many_bulk_unlink
+
+        def pre_run
+            super
+            action.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 ids.is_a?(Array)
+            assoc = assets[:assoc]
+            case assoc[:type]
+            when :one_to_many
+                one_to_many_unlink_db(handler, ids)
+            when :many_to_many
+                handler.permit parent = handler.params[:parent_id]
+                many_to_many_unlink_db(parent, ids)
+            else unsupported_association
+            end
+        end
+    end
+end

data/lib/engine2/meta/list_meta.rb

@@ -0,0 +1,284 @@
+# coding: utf-8
+
+module Engine2
+    class ListMeta < Meta
+        meta_type :list
+        include MetaListSupport, MetaQuerySupport
+
+        (DefaultFilters ||= {}).merge!(
+            string: lambda{|query, name, value, type_info, hash|
+                case type_info[:type]
+                when :many_to_one
+                    query.where(name => value)
+                else
+                    query.where(name.like("%#{value}%"))
+                end
+            },
+            date: lambda{|query, name, value, type_info, hash|
+                if value.is_a? Hash
+                    from, to = value[:from], value[:to]
+                    if from && to
+                        query.where(name => from .. to)
+                    elsif from
+                        query.where(name >= Sequel.string_to_date(from))
+                    elsif to
+                        query.where(name <= Sequel.string_to_date(to))
+                    else
+                        query # ?
+                    end
+                else
+                    query.where(name => Sequel.string_to_date(value))
+                end
+            },
+            integer: lambda{|query, name, value, type_info, hash|
+                if value.is_a? Hash
+                    from, to = value[:from], value[:to]
+                    if from && to
+                        query.where(name => from .. to)
+                    else
+                        query.where(from ? name >= from.to_i : name <= to.to_i)
+                    end
+                elsif value.is_a? Integer
+                    query.where(name => value)
+                elsif value.is_a? Array
+                    if !value.empty?
+                        case type_info[:type]
+                        when :many_to_one
+                            keys = type_info[:keys]
+                            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
+                                })
+                            end
+                        when :list_select
+                            query.where(name => value) # decode in sql query ?
+                        when :integer
+                            query
+                        else
+                            nil
+                        end
+                    else
+                        nil
+                    end
+                else
+                    nil
+                end
+            }
+        )
+
+        def post_run
+            query select(*assets[:model].columns.reject{|col| assets[:model].type_info[col][:length].to_i > 20}.take(10)) unless @query
+            super
+        end
+
+        def invoke handler
+            params = handler.params
+            model = assets[:model]
+            query = list_context(get_query, handler)
+
+            if search = params[:search]
+                query = list_search(query, handler, search)
+            end
+
+            count = query.count if lookup(:config, :use_count)
+
+            if order_str = params[:order]
+                order = order_str.to_sym
+                handler.permit lookup(:info, order, :sort)
+
+                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]
+                    query = query.order(order)
+                end
+
+                query = query.reverse if params[:asc] == "true"
+            end
+
+            per_page = lookup(:config, :per_page)
+            page = params[:page].to_i
+            handler.permit page >= 0 && page < 1000
+
+            query = query.limit(per_page, page)
+
+            res = {entries: query.all}
+            res[:count] = count if count
+            res
+        end
+
+        def list_search query, handler, search
+            hash = JSON.parse(search, symbolize_names: true) rescue handler.halt_forbidden
+            model = assets[:model]
+            sfields = lookup(:search_fields)
+            handler.permit sfields
+            hash.each_pair do |name, value|
+                handler.permit sfields.include?(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)
+                    filter.(query, name, value, type_info, hash)
+                else
+                    raise E2Error.new("Filter not found for field #{name} in model #{model}") unless filter
+                end
+
+                handler.permit query
+            end
+            query
+        end
+
+        def list_context query, handler
+            query
+        end
+    end
+
+    #
+    # Many to One
+    #
+    class ManyToOneListMeta < ListMeta
+        meta_type :many_to_one_list
+
+        def pre_run
+            super
+            config.merge!(selectable: false)
+        end
+    end
+
+    #
+    # * to Many
+    #
+    class StarToManyListMeta < ListMeta
+        meta_type :star_to_many_list
+        def pre_run
+            super
+            panel_title "#{glyphicon('list')} #{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]
+            assoc = assets[:assoc]
+            case assoc[:type]
+            when :one_to_many
+                keys = assoc[:keys]
+                condition = parent.empty? ? false : Hash[keys.map{|k| k.qualify(model.table_name)}.zip(split_keys(parent))]
+                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] ?
+                    query
+                else
+                    query.where(condition)
+                end
+            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)}
+                r_keys_vals = Hash[r_keys.zip(q_pk)]
+                l_keys_vals = parent.empty? ? false : Hash[l_keys.zip(split_keys(parent))]
+
+                if handler.params[:negate]
+                    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)
+                end
+            else unsupported_association
+            end
+        end
+    end
+
+    class StarToManyLinkListMeta < StarToManyListMeta
+        meta_type :star_to_many_link_list
+        def pre_run
+            super
+            config.merge!(selectable: false)
+            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
+        end
+    end
+
+    # *_to_many_field
+    class StarToManyFieldMeta < StarToManyListMeta
+        meta_type :star_to_many_field
+
+        def pre_run
+            super
+            modal_action false
+            panel_panel_template false
+            # panel_template nil
+        end
+
+        def list_context query, handler
+            unlinked = handler.param_to_json(:unlinked)
+            linked = handler.param_to_json(:linked)
+            query = super(query, handler)
+            model = assets[:model]
+            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}
+
+            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]
+                when :one_to_many
+                    query = linked.map{|ln| pks.zip(split_keys(ln))}.inject(query){|q, c| q.or c}
+                when :many_to_many
+                    query = linked.map{|ln| pks.zip(split_keys(ln))}.inject(query){|q, c| q.or c}.distinct
+                else unsupported_association
+                end unless linked.empty?
+            end
+
+            query
+        end
+    end
+
+    class StarToManyFieldUnlinkMeta < Meta
+        meta_type :star_to_many_field_unlink
+
+        def pre_run
+            super
+            action.parent.parent.*.menu(:item_menu).option :confirm_unlink, icon: "minus", show: "action.selected_size() == 0", button_loc: false
+        end
+    end
+
+    class StarToManyFieldLinkListMeta < StarToManyFieldMeta
+        meta_type :star_to_many_field_link_list
+
+        def pre_run
+            super
+            config.merge!(selectable: false)
+            modal_action true
+            panel_panel_template 'scaffold/list'
+            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
+        end
+    end
+end
+

data/lib/engine2/meta/save_meta.rb

@@ -0,0 +1,63 @@
+# coding: utf-8
+
+module Engine2
+
+    class SaveMeta < Meta
+        include MetaApproveSupport
+        http_method :post
+
+        def validate_and_approve handler, record, json
+            record.skip_save_refresh = true
+            record.raise_on_save_failure = false
+            model = assets[:model]
+            assoc = assets[:assoc]
+            mtm_insert = record.new? && assoc && assoc[:type] == :many_to_many
+
+            save = lambda do|c|
+                if super(handler, record, json)
+                    result = record.save(transaction: false, validate: false)
+                    if result && mtm_insert
+                        handler.permit parent_id = json[:parent_id]
+                        model.db[assoc[:join_table]].insert(assoc[:left_keys] + assoc[:right_keys], split_keys(parent_id) + record.primary_key_values)
+                    end
+                    result
+                end
+            end
+            (model.validation_in_transaction || mtm_insert) ? model.db.transaction(&save) : save.(nil)
+        end
+    end
+
+    class InsertMeta < SaveMeta
+        meta_type :save
+        def allocate_record handler, json
+            record = super(handler, json)
+            record.instance_variable_set(:"@new", true)
+            model = assets[:model]
+            model.primary_keys.each{|k|record.values.delete k} unless model.natural_key
+            handler.permit !record.has_primary_key? unless model.natural_key
+            record
+        end
+    end
+
+    class UpdateMeta < SaveMeta
+        meta_type :save
+        def allocate_record handler, json
+            record = super(handler, json)
+            model = assets[:model]
+            handler.permit record.has_primary_key? unless model.natural_key
+            record
+        end
+    end
+
+    module TimeStampMeta
+        def before_approve handler, record
+            super
+            puts "before approve"
+        end
+
+        def after_approve handler, record
+            super
+            puts "after approve"
+        end
+    end
+end