},\r
by_author: {\r
type: 'filter',\r
- from: 'author',\r
- filter_key: 'author_id',\r
+ args: {\r
+ filter_item_name: 'author',\r
+ filter_key: 'author_id',\r
+ },\r
},\r
by_panel: {\r
type: 'through_filter',\r
require_dependency "manifest/filer"
require_dependency "manifest/form"
require_dependency "manifest/list"
-require_dependency "manifest/system_resources"
+require_dependency "manifest/system_resource"
require_dependency "manifest/local/view"
Manifest::load JSON.parse(open(File.expand_path('../../public/manifest.json', __FILE__)).read)
'list' => ActionList, 'show' => ActionShow
}
def self.factory controller, action_name, my_manifest
+ my_manifest['type'] ||= 'list'
type = my_manifest['type']
raise "undefined type for controllers > #{controller.controller_name} > action > #{action_name}\n" unless type
my_class = @@types[type]
def init
super
- raise "undefined list_name for controllers > #{self.controller_name} > actions > #{@action_name} > args\n" unless @args['list_name']
+ raise "undefined list_name for controllers > #{self.controller_name} > actions > #{@action_name}\n" unless @args['list_name']
@list_name = @args['list_name']
end
end
def items options, offset, page_size
- @model.where(self.where(filter_item)).includes(self.includes).order(self.order).offset(offset).limit(page_size)
+ @model.where(self.where).includes(self.includes).order(self.order).offset(offset).limit(page_size)
end
def paginate items, offset, page_size
def init
super
- return
end
def where filter_item
w.merge({@from => {} })
end
- def items filter_item
- @model.where(self.where(filter_item)).includes(self.includes).order(self.order).offset(@offset).limit(@page_size)
- end
-
- def paginate filter_item
- Kaminari.paginate_array(Array.new(@model.where(self.where(filter_item)).includes(self.includes).count, nil)).page(@offset).per(@page_size)
+ def items options, offset, page_size
+ filter_item = options[:filter_item]
+ @model.where(self.where(filter_item)).includes(self.includes).order(self.order).offset(offset).limit(page_size)
end
def self._add_action item_name, action_name, list_name, list_conf
@model.list_order
end
- def items options, offset, page_size
- @model.where(self.where()).includes(self.includes).order(self.order).offset(offset).limit(page_size)
- end
-
end
end
module Manifest
module ListModule
class SystemResourceList < Base
- attr :select_item_name
def set_default
super
def init
super
- @select_item_name = @list_manifest['select_item_name']
end
def items options, offset, page_size
# ex. it's adding license_groups routes
def initialize manifest
@manifest = manifest || {}
- @system_resources = SystemResources.new(self, SystemResources.set_default(@manifest['system_resources']))
+ @system_resources = SystemResource.new(self, SystemResource.set_default(@manifest['system_resources']))
@magic_numbers = @manifest['magic_numbers']
end
require_dependency "manifest/system_resource/engine_resource"
module Manifest
- class SystemResources
+ class SystemResource
include SystemResourceModule
- def self.set_default system_resources_manifest
- system_resources_manifest['engine_resources'] ||= {}
- system_resources_manifest['elements'] ||= {}
- system_resources_manifest['select_items'] ||= {}
+ def self.set_default system_resource_manifest
+ system_resource_manifest['engine_resources'] ||= {}
+ system_resource_manifest['elements'] ||= {}
+ system_resource_manifest['select_items'] ||= {}
#oh my ...
#JSON.stringify couldn't print 1.0
# 1 == 1.0 ?
#change class
- system_resources_manifest['select_items']['speech_font_size_items'] ||= {}
- system_resources_manifest['select_items']['speech_font_size_items'].each {|conf|
+ system_resource_manifest['select_items']['speech_font_size_items'] ||= {}
+ system_resource_manifest['select_items']['speech_font_size_items'].each {|conf|
conf[1] = conf[1].to_f
}
- system_resources_manifest
+ system_resource_manifest
end
attr :engine_resources, :elements, :select_items
- def initialize manifest, system_resources_manifest
+ def initialize manifest, system_resource_manifest
@manifest = manifest
- @system_resources_manifest = system_resources_manifest
- @engine_resources = EngineResource.manager(self, @system_resources_manifest['engine_resources'])
- @elements = system_resources_manifest['elements']
- @select_items = system_resources_manifest['select_items']
+ @system_resource_manifest = system_resource_manifest
+ @engine_resources = EngineResource.manager(self, @system_resource_manifest['engine_resources'])
+ @elements = system_resource_manifest['elements']
+ @select_items = system_resource_manifest['select_items']
end
# call after load app
module Manifest
module SystemResourceModule
class EngineResource
- def self.manager manifest, my_manifests
+ def self.manager system_resource, my_manifests
engine_resources = {}
my_manifests.each {|engine_resource_name, engine_resource_manifest|
- engine_resources[engine_resource_name] = self.new(manifest, engine_resource_name, engine_resource_manifest)
+ engine_resources[engine_resource_name] = self.new(system_resource, engine_resource_name, engine_resource_manifest)
}
engine_resources
end
attr :engine_resource_name, :engine_resource_manifest,
:resource_items, :has_route
- def initialize manifest, engine_resource_name, engine_resource_manifest
- @manifest = manifest
+ def initialize system_resource, engine_resource_name, engine_resource_manifest
+ @system_resource = system_resource
@engine_resource_name = engine_resource_name
@engine_resource_manifest = engine_resource_manifest
self.set_default