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         if @owner_model
  44           if @owner_model.owner_model
  45             {@owner_model.item_name => {@owner_model.owner_model.item_name => {}}}
  46           else
  47             {@owner_model.item_name => {}}
  48           end
  49         else
  50           {}
  51         end
  52       end
  53
  54       def order
  55         @model.list_order
  56       end
  57
  58       def items
  59         @model.where(self.where()).includes(self.includes).order(self.order).offset(@offset).limit(@page_size)
  60       end
  61
  62       def paginate
  63         c = @model.where(self.where()).includes(self.includes).count
  64         Kaminari.paginate_array(Array.new(c, nil)).page(@offset).per(@page_size)
  65       end
  66
  67     end
  68
  69     class PublicList < BaseList
  70     end
  71
  72     class PrivateList < BaseList
  73       def where
  74         case @model.owner_type
  75         when :author
  76           operator = @operators.author
  77         when :artist
  78           operator = @operators.artist
  79         end
  80         t = if @owner_model
  81           if @owner_model.owner_model
  82             @owner_model.owner_model.table_name
  83           else
  84             @owner_model.table_name
  85           end
  86         else
  87           @table_name
  88         end
  89         [t + '.' + @model.owner_type.to_s + '_id = ?', operator.id]
  90       end
  91     end
  92
  93     class HasManyList < BaseList
  94       def initialize page, page_size, operators, item_name, list_name, conf, manifest
  95         super
  96         @association_name = @conf['association_name']
  97         @has_many_conf = @manifest.model(@item_name).associations['has_many'] || {}
  98         @association_conf = @has_many_conf[@association_name] || {}
  99         @association_model_name = @association_conf['model']
 100         @association_model = @association_model_name.classify.constantize
 101         @foreign_key = @association_conf['foreign_key']
 102       end
 103
 104       def where parent_item
 105         w = @model.list_where
 106         w += ' and ' unless w.blank?
 107         t = @owner_model ? @owner_table_name : @table_name
 108         [w + @association_model_name + '.' + @foreign_key + ' = ?', parent_item.id]
 109       end
 110
 111       def includes
 112   #   @with_model_name ? {@with_model_name.classify.constantize.table_name => {}} : {}
 113         w = @owner_model ? {@owner_model.item_name => {}} : {}
 114         w.merge({@association_model.table_name => {} })
 115       end
 116
 117       def items parent_item
 118         @model.where(self.where(parent_item)).includes(self.includes).order(self.order).offset(@offset).limit(@page_size)
 119       end
 120
 121       def paginate parent_item
 122         Kaminari.paginate_array(Array.new(@model.where(self.where(parent_item).includes(self.includes)).count, nil)).page(@offset).per(@page_size)
 123       end
 124
 125     end
 126
 127     class FilterList < BaseList
 128       def initialize page, page_size, operators, item_name, list_name, conf, manifest
 129         super
 130         @list_list_conf = @manifest.list(@item_name).lists[list_name] || {}
 131         @from = @list_list_conf['from']
 132         @filter_key = @list_list_conf['filter_key']
 133         @includes = @list_list_conf['includes']
 134
 135         @with_model_name = @list_list_conf['with']
 136       end
 137
 138       def where filter_item
 139         w = @model.list_where
 140         w += ' and ' unless w.blank?
 141         [w + @table_name + '.' + @filter_key + ' = ?', filter_item.id]
 142       end
 143
 144       def includes
 145         return @includes if @includes
 146         w = @owner_model ? {@owner_model.item_name => {}} : {}
 147         w.merge({@from => {} })
 148       end
 149
 150       def items filter_item
 151         @model.where(self.where(filter_item)).includes(self.includes).order(self.order).offset(@offset).limit(@page_size)
 152       end
 153
 154       def paginate filter_item
 155         Kaminari.paginate_array(Array.new(@model.where(self.where(filter_item).includes(self.includes)).count, nil)).page(@offset).per(@page_size)
 156       end
 157
 158     end
 159
 160     class ThroughFilterList < FilterList
 161       def initialize page, page_size, operators, item_name, list_name, conf, manifest
 162         super
 163         @through = @list_list_conf['through']
 164       end
 165
 166       def includes
 167         {@through => {@from => {}} }
 168       end
 169
 170       def where filter_item
 171         w = @model.list_where
 172         w += ' and ' unless w.blank?
 173         [w + @through + '.' + @filter_key + ' = ?', filter_item.id]
 174       end
 175
 176     end
 177
 178     class ElementFilterList < FilterList
 179       def includes
 180         {@owner_model.item_name => {}}
 181       end
 182
 183       def where filter_item
 184         w = @model.list_where
 185         w += ' and ' unless w.blank?
 186         [w + @owner_table_name + '.' + @filter_key + ' = ?', filter_item.id]
 187       end
 188
 189     end
 190
 191     @@types = {
 192       'public' => PublicList, 'private' => PrivateList,
 193       'has_many' => HasManyList, 'filter' => FilterList,
 194       'through_filter' => ThroughFilterList, 'element_filter' => ElementFilterList
 195     }
 196     def initialize list_manifest
 197       @list_manifest = list_manifest
 198       @item_name = @list_manifest.item_name
 199       @manifest = @list_manifest.manifest
 200       @list_conf = @list_manifest.conf
 201       @lists = {}
 202       @list_manifest.lists.each {|list_name, conf|
 203         type = conf['type']
 204         @lists[list_name] = @@types[type]
 205       }
 206     end
 207
 208     def open list_name, page, page_size, operators
 209       raise "undefined list for #{@item_name}::#{list_name}\nconf:#{@list_conf}\n" unless @lists[list_name]
 210       @lists[list_name].new page, page_size, operators, @item_name, list_name, @list_conf, @manifest
 211     end
 212
 213   end
 214 end
 215