lib/manifest/list.rb

   1
   2 module Pettanr
   3   class ListManager
   4     class BaseList
   5       def initialize page, page_size, operators, item_name, list_name, conf, manifest
   6         @operators = operators
   7         @item_name = item_name
   8         @list_name = list_name
   9         @conf = conf
  10         @manifest = manifest
  11         @default_page_size = @conf['default_page_size'] || 25
  12         @max_page_size = @conf['max_page_size'] || 100
  13         @page = self.page_number(page)
  14         @page_size = self.page_size page_size
  15
  16         @model = @item_name.classify.constantize
  17         @offset = (@page -1) * @page_size
  18         @table_name = @model.table_name
  19        if @model.content?
  20           @owner_model = @model.owner_model
  21           @owner_table_name = @owner_model.table_name if @owner_model
  22         end
  23       end
  24
  25       def page_number prm = nil
  26         page = prm.to_i
  27         page = 1 if page < 1
  28         page
  29       end
  30
  31       def page_size prm
  32         page_size = prm.to_i
  33         page_size = @max_page_size if page_size > @max_page_size
  34         page_size = @default_page_size if page_size < 1
  35         page_size
  36       end
  37
  38       def where
  39         @model.list_where
  40       end
  41
  42       def includes
  43         @owner_model ? {@owner_model.item_name => {}} : {}
  44       end
  45
  46       def order
  47         @model.list_order
  48       end
  49
  50       def items
  51         @model.where(self.where()).includes(self.includes).order(self.order).offset(@offset).limit(@page_size)
  52       end
  53
  54       def paginate
  55         c = @model.where(self.where()).includes(self.includes).count
  56         Kaminari.paginate_array(Array.new(c, nil)).page(@offset).per(@page_size)
  57       end
  58
  59     end
  60
  61     class PublicList < BaseList
  62     end
  63
  64     class PrivateList < BaseList
  65       def where
  66         case @model.owner_type
  67         when :author
  68           operator = @operators.author
  69         when :artist
  70           operator = @operators.artist
  71         end
  72         t = @owner_model ? @owner_table_name : @table_name
  73         [t + '.' + @model.owner_type.to_s + '_id = ?', operator.id]
  74       end
  75
  76     end
  77
  78     class HasManyList < BaseList
  79       def initialize page, page_size, operators, item_name, list_name, conf, manifest
  80         super
  81         @association_name = @conf['association_name']
  82         @has_many_conf = @manifest.model(@item_name).associations['has_many'] || {}
  83         @association_conf = @has_many_conf[@association_name] || {}
  84         @association_model_name = @association_conf['model']
  85         @association_model = @association_model_name.classify.constantize
  86         @foreign_key = @association_conf['foreign_key']
  87       end
  88
  89       def where parent_item
  90         w = @model.list_where
  91         w += ' and ' unless w.blank?
  92         t = @owner_model ? @owner_table_name : @table_name
  93         [w + @association_model_name + '.' + @foreign_key + ' = ?', parent_item.id]
  94       end
  95
  96       def includes
  97      @with_model_name ? {@with_model_name.classify.constantize.table_name => {}} : {}
  98         w = @owner_model ? {@owner_model.item_name => {}} : {}
  99         w.merge({@association_model.table_name => {} })
 100       end
 101
 102       def items parent_item
 103         @model.where(self.where(parent_item)).includes(self.includes).order(self.order).offset(@offset).limit(@page_size)
 104       end
 105
 106       def paginate parent_item
 107         Kaminari.paginate_array(Array.new(@model.where(self.where(parent_item).includes(self.includes)).count, nil)).page(@offset).per(@page_size)
 108       end
 109
 110     end
 111
 112     class FilterList < BaseList
 113       def initialize page, page_size, operators, item_name, list_name, conf, manifest
 114         super
 115         @list_list_conf = @manifest.list(@item_name).lists[list_name] || {}
 116         @from = @list_list_conf['from']
 117         @filter_key = @list_list_conf['filter_key']
 118
 119         @with_model_name = @list_list_conf['with']
 120       end
 121
 122       def where filter_item
 123         w = @model.list_where
 124         w += ' and ' unless w.blank?
 125         [w + @table_name + '.' + @filter_key + ' = ?', filter_item.id]
 126       end
 127
 128       def includes
 129         w = @owner_model ? {@owner_model.item_name => {}} : {}
 130         w.merge({@from => {} })
 131       end
 132
 133       def items filter_item
 134         @model.where(self.where(filter_item)).includes(self.includes).order(self.order).offset(@offset).limit(@page_size)
 135       end
 136
 137       def paginate filter_item
 138         Kaminari.paginate_array(Array.new(@model.where(self.where(filter_item).includes(self.includes)).count, nil)).page(@offset).per(@page_size)
 139       end
 140
 141     end
 142
 143     class ThroughFilterList < FilterList
 144       def initialize page, page_size, operators, item_name, list_name, conf, manifest
 145         super
 146         @through = @list_list_conf['through']
 147       end
 148
 149       def includes
 150         {@through => {@from => {}} }
 151       end
 152
 153       def where filter_item
 154         w = @model.list_where
 155         w += ' and ' unless w.blank?
 156         [w + @through + '.' + @filter_key + ' = ?', filter_item.id]
 157       end
 158
 159     end
 160
 161     class ElementFilterList < FilterList
 162       def includes
 163         {@owner_model.item_name => {}}
 164       end
 165
 166       def where filter_item
 167         w = @model.list_where
 168         w += ' and ' unless w.blank?
 169         [w + @owner_table_name + '.' + @filter_key + ' = ?', filter_item.id]
 170       end
 171
 172     end
 173
 174     @@types = {
 175       'public' => PublicList, 'private' => PrivateList,
 176       'has_many' => HasManyList, 'filter' => FilterList,
 177       'through_filter' => ThroughFilterList, 'element_filter' => ElementFilterList
 178     }
 179     def initialize list_manifest
 180       @list_manifest = list_manifest
 181       @item_name = @list_manifest.item_name
 182       @manifest = @list_manifest.manifest
 183       @list_conf = @list_manifest.conf
 184       @lists = {}
 185       @list_manifest.lists.each {|list_name, conf|
 186         type = conf['type']
 187         @lists[list_name] = @@types[type]
 188       }
 189     end
 190
 191     def open list_name, page, page_size, operators
 192       raise "undefined list for #{@item_name}::#{list_name}\nconf:#{@list_conf}\n" unless @lists[list_name]
 193       @lists[list_name].new page, page_size, operators, @item_name, list_name, @list_conf, @manifest
 194     end
 195
 196   end
 197 end
 198