engine2 1.0.4 → 1.0.5

data/lib/engine2/meta/delete_meta.rb

@@ -1,60 +0,0 @@
-# coding: utf-8
-
-module Engine2
-    class DeleteMetaBase < Meta
-
-        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
-        include MetaDeleteSupport
-
-        def invoke handler
-            handler.permit id = handler.params[:id]
-            invoke_delete_db(handler, [id])
-        end
-    end
-
-    class BulkDeleteMeta < DeleteMetaBase
-        include MetaBulkDeleteSupport
-
-        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

@@ -1,15 +0,0 @@
-# coding: utf-8
-
-module Engine2
-    class FormMeta < Meta
-        include MetaQuerySupport
-    end
-
-    class CreateMeta < FormMeta
-        include MetaCreateSupport
-    end
-
-    class ModifyMeta < FormMeta
-        include MetaModifySupport
-    end
-end

data/lib/engine2/meta/link_meta.rb

@@ -1,134 +0,0 @@
-# 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.*.select_toggle_menu
-            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/save_meta.rb

@@ -1,50 +0,0 @@
-# coding: utf-8
-
-module Engine2
-
-    class SaveMeta < Meta
-        include MetaApproveSupport
-
-        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 :approve
-        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 :approve
-        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
-end

data/lib/engine2/meta/view_meta.rb

@@ -1,7 +0,0 @@
-# coding: utf-8
-
-module Engine2
-    class ViewMeta < Meta
-        include MetaViewSupport, MetaQuerySupport
-    end
-end