lib/manifest/list.rb

   1
   2 module Pettanr
   3   class ListManager
   4     class PublicList
   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       end
  19
  20       def page_number prm = nil
  21         page = prm.to_i
  22         page = 1 if page < 1
  23         page
  24       end
  25
  26       def page_size prm
  27         page_size = prm.to_i
  28         page_size = @max_page_size if page_size > @max_page_size
  29         page_size = @default_page_size if page_size < 1
  30         page_size
  31       end
  32
  33       def where
  34         @model.list_where
  35       end
  36
  37       def items
  38         @model.where(self.where()).includes(@model.list_opt).order(@model.list_order).offset(@offset).limit(@page_size)
  39       end
  40
  41       def paginate
  42         Kaminari.paginate_array(Array.new(@model.where(self.where()).includes(@model.list_opt).count, nil)).page(@offset).per(@page_size)
  43       end
  44
  45     end
  46
  47     class PrivateList
  48       def initialize page, page_size, operators, item_name, list_name, conf, manifest
  49         @operators = operators
  50         @item_name = item_name
  51         @conf = conf
  52         @manifest = manifest
  53         @default_page_size = @conf['default_page_size'] || 25
  54         @max_page_size = @conf['max_page_size'] || 100
  55         @page = self.page_number(page)
  56         @page_size = self.page_size page_size
  57
  58         @model = @item_name.classify.constantize
  59         @offset = (@page -1) * @page_size
  60       end
  61
  62       def page_number prm = nil
  63         page = prm.to_i
  64         page = 1 if page < 1
  65         page
  66       end
  67
  68       def page_size prm
  69         page_size = prm.to_i
  70         page_size = @max_page_size if page_size > @max_page_size
  71         page_size = @default_page_size if page_size < 1
  72         page_size
  73       end
  74
  75       def where
  76         case @model.owner_type
  77         when :author
  78           operator = @operators.author
  79         when :artist
  80           operator = @operators.artist
  81         end
  82         [@model.plural + '.' + @model.owner_type.to_s + '_id = ?', operator.id]
  83       end
  84
  85       def items
  86         @model.where(self.where()).includes(@model.list_opt).order(@model.list_order).offset(@offset).limit(@page_size)
  87       end
  88
  89       def paginate
  90         Kaminari.paginate_array(Array.new(@model.where(self.where()).includes(@model.list_opt).count, nil)).page(@offset).per(@page_size)
  91       end
  92
  93     end
  94
  95     class HasManyList
  96       def initialize page, page_size, operators, item_name, list_name, conf, manifest
  97         @operators = operators
  98         @item_name = item_name
  99         @list_name = list_name
 100         @conf = conf
 101         @manifest = manifest
 102         @default_page_size = @conf['default_page_size'] || 25
 103         @max_page_size = @conf['max_page_size'] || 100
 104         @page = self.page_number(page)
 105         @page_size = self.page_size page_size
 106
 107         @model = @item_name.classify.constantize
 108         @offset = (@page -1) * @page_size
 109         @association_name = @conf['association_name']
 110         @has_many_conf = @manifest.model(@item_name).associations['has_many'] || {}
 111         @association_conf = @has_many_conf[@association_name] || {}
 112         @association_model_name = @association_conf['model']
 113         @association_model = @association_model_name.classify.constantize
 114         @foreign_key = @association_conf['foreign_key']
 115       end
 116
 117       def page_number prm = nil
 118         page = prm.to_i
 119         page = 1 if page < 1
 120         page
 121       end
 122
 123       def page_size prm
 124         page_size = prm.to_i
 125         page_size = @max_page_size if page_size > @max_page_size
 126         page_size = @default_page_size if page_size < 1
 127         page_size
 128       end
 129
 130       def where parent_item
 131         w = @model.list_where
 132         w += ' and ' unless w.blank?
 133         [w + @association_model_name + '.' + @foreign_key + ' = ?', parent_item.id]
 134       end
 135
 136       def items parent_item
 137         @model.where(self.where(parent_item)).includes(@model.list_opt).order(@model.list_order).offset(@offset).limit(@page_size)
 138       end
 139
 140       def paginate
 141         Kaminari.paginate_array(Array.new(@model.where(self.where(parent_item)).includes(@model.list_opt).count, nil)).page(@offset).per(@page_size)
 142       end
 143
 144     end
 145
 146     class FilterList
 147       def initialize page, page_size, operators, item_name, list_name, conf, manifest
 148         @operators = operators
 149         @item_name = item_name
 150         @list_name = list_name
 151         @conf = conf
 152         @manifest = manifest
 153         @default_page_size = @conf['default_page_size'] || 25
 154         @max_page_size = @conf['max_page_size'] || 100
 155         @page = self.page_number(page)
 156         @page_size = self.page_size page_size
 157
 158         @model = @item_name.classify.constantize
 159         @table_name = @model.table_name
 160         @offset = (@page -1) * @page_size
 161         @list_list_conf = @manifest.list(@item_name).lists[list_name] || {}
 162         @from = @list_list_conf['from']
 163         @filter_key = @list_list_conf['filter_key']
 164       end
 165
 166       def page_number prm = nil
 167         page = prm.to_i
 168         page = 1 if page < 1
 169         page
 170       end
 171
 172       def page_size prm
 173         page_size = prm.to_i
 174         page_size = @max_page_size if page_size > @max_page_size
 175         page_size = @default_page_size if page_size < 1
 176         page_size
 177       end
 178
 179       def list_opt
 180         {@from => {} }
 181       end
 182
 183       def where filter_item
 184         w = @model.list_where
 185         w += ' and ' unless w.blank?
 186         [w + @table_name + '.' + @filter_key + ' = ?', filter_item.id]
 187       end
 188
 189       def items filter_item
 190         @model.where(self.where(filter_item)).includes(self.list_opt).order(@model.list_order).offset(@offset).limit(@page_size)
 191       end
 192
 193       def paginate filter_item
 194         Kaminari.paginate_array(Array.new(@model.where(self.where(filter_item)).includes(self.list_opt).count, nil)).page(@offset).per(@page_size)
 195       end
 196
 197     end
 198
 199     class ThroughFilterList
 200       def initialize page, page_size, operators, item_name, list_name, conf, manifest
 201         @operators = operators
 202         @item_name = item_name
 203         @list_name = list_name
 204         @conf = conf
 205         @manifest = manifest
 206         @default_page_size = @conf['default_page_size'] || 25
 207         @max_page_size = @conf['max_page_size'] || 100
 208         @page = self.page_number(page)
 209         @page_size = self.page_size page_size
 210
 211         @model = @item_name.classify.constantize
 212         @table_name = @model.table_name
 213         @offset = (@page -1) * @page_size
 214         @list_list_conf = @manifest.list(@item_name).lists[list_name] || {}
 215         @filter_key = @list_list_conf['filter_key']
 216         @from = @list_list_conf['from']
 217         @through = @list_list_conf['through']
 218       end
 219
 220       def page_number prm = nil
 221         page = prm.to_i
 222         page = 1 if page < 1
 223         page
 224       end
 225
 226       def page_size prm
 227         page_size = prm.to_i
 228         page_size = @max_page_size if page_size > @max_page_size
 229         page_size = @default_page_size if page_size < 1
 230         page_size
 231       end
 232
 233       def list_opt
 234         {@through => {@from => {}} }
 235       end
 236
 237       def where filter_item
 238         w = @model.list_where
 239         w += ' and ' unless w.blank?
 240         [w + @through + '.' + @filter_key + ' = ?', filter_item.id]
 241       end
 242
 243       def items filter_item
 244         @model.where(self.where(filter_item)).includes(self.list_opt).order(@model.list_order).offset(@offset).limit(@page_size)
 245       end
 246
 247       def paginate filter_item
 248         Kaminari.paginate_array(Array.new(@model.where(self.where(filter_item)).includes(self.list_opt).count, nil)).page(@offset).per(@page_size)
 249       end
 250
 251     end
 252
 253     @@types = {'public' => PublicList, 'private' => PrivateList, 'has_many' => HasManyList, 'filter' => FilterList, 'through_filter' => ThroughFilterList}
 254     def initialize list_manifest
 255       @list_manifest = list_manifest
 256       @item_name = @list_manifest.item_name
 257       @manifest = @list_manifest.manifest
 258       @list_conf = @list_manifest.conf
 259       @lists = {}
 260       @list_manifest.lists.each {|list_name, conf|
 261         type = conf['type']
 262         @lists[list_name] = @@types[type]
 263       }
 264     end
 265
 266     def open list_name, page, page_size, operators
 267       @lists[list_name].new page, page_size, operators, @item_name, list_name, @list_conf, @manifest
 268     end
 269
 270   end
 271 end
 272