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       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 PublicList
  48       def initialize page, page_size, operators, item_name, list_name, conf, manifest
  49         @operators = operators
  50         @item_name = item_name
  51         @list_name = list_name
  52         @conf = conf
  53         @manifest = manifest
  54         @default_page_size = @conf['default_page_size'] || 25
  55         @max_page_size = @conf['max_page_size'] || 100
  56         @page = self.page_number(page)
  57         @page_size = self.page_size page_size
  58
  59         @model = @item_name.classify.constantize
  60         @offset = (@page -1) * @page_size
  61       end
  62
  63       def page_number prm = nil
  64         page = prm.to_i
  65         page = 1 if page < 1
  66         page
  67       end
  68
  69       def page_size prm
  70         page_size = prm.to_i
  71         page_size = @max_page_size if page_size > @max_page_size
  72         page_size = @default_page_size if page_size < 1
  73         page_size
  74       end
  75
  76       def where
  77         @model.list_where
  78       end
  79
  80       def items
  81         @model.where(self.where()).includes(@model.list_opt).order(@model.list_order).offset(@offset).limit(@page_size)
  82       end
  83
  84       def paginate
  85         Kaminari.paginate_array(Array.new(@model.where(self.where()).includes(@model.list_opt).count, nil)).page(@offset).per(@page_size)
  86       end
  87
  88     end
  89
  90     class SystemResourceList
  91       def items
  92         @model.where(self.where()).includes(@model.list_opt).order(@model.list_order).offset(@offset).limit(@page_size).delete_if {|sbt|
  93           Pettanr::Application.manifest.system_resources.speech_balloon_templates[sbt.classname] == nil
  94         }
  95       end
  96
  97       def paginate
  98         Kaminari.paginate_array(Array.new(@model.where(self.where()).includes(@model.list_opt).count, nil)).page(@offset).per(@page_size)
  99       end
 100
 101     end
 102
 103     class PrivateList
 104       def initialize page, page_size, operators, item_name, list_name, conf, manifest
 105         @operators = operators
 106         @item_name = item_name
 107         @conf = conf
 108         @manifest = manifest
 109         @default_page_size = @conf['default_page_size'] || 25
 110         @max_page_size = @conf['max_page_size'] || 100
 111         @page = self.page_number(page)
 112         @page_size = self.page_size page_size
 113
 114         @model = @item_name.classify.constantize
 115         @offset = (@page -1) * @page_size
 116       end
 117
 118       def page_number prm = nil
 119         page = prm.to_i
 120         page = 1 if page < 1
 121         page
 122       end
 123
 124       def page_size prm
 125         page_size = prm.to_i
 126         page_size = @max_page_size if page_size > @max_page_size
 127         page_size = @default_page_size if page_size < 1
 128         page_size
 129       end
 130
 131       def where
 132         case @model.owner_type
 133         when :author
 134           operator = @operators.author
 135         when :artist
 136           operator = @operators.artist
 137         end
 138         [@model.plural + '.' + @model.owner_type.to_s + '_id = ?', operator.id]
 139       end
 140
 141       def items
 142         @model.where(self.where()).includes(@model.list_opt).order(@model.list_order).offset(@offset).limit(@page_size)
 143       end
 144
 145       def paginate
 146         Kaminari.paginate_array(Array.new(@model.where(self.where()).includes(@model.list_opt).count, nil)).page(@offset).per(@page_size)
 147       end
 148
 149     end
 150
 151     class HasManyList
 152       def initialize page, page_size, operators, item_name, list_name, conf, manifest
 153         @operators = operators
 154         @item_name = item_name
 155         @list_name = list_name
 156         @conf = conf
 157         @manifest = manifest
 158         @default_page_size = @conf['default_page_size'] || 25
 159         @max_page_size = @conf['max_page_size'] || 100
 160         @page = self.page_number(page)
 161         @page_size = self.page_size page_size
 162
 163         @model = @item_name.classify.constantize
 164         @offset = (@page -1) * @page_size
 165         @association_name = @conf['association_name']
 166         @has_many_conf = @manifest.model(@item_name).associations['has_many'] || {}
 167         @association_conf = @has_many_conf[@association_name] || {}
 168         @association_model_name = @association_conf['model']
 169         @association_model = @association_model_name.classify.constantize
 170         @foreign_key = @association_conf['foreign_key']
 171       end
 172
 173       def page_number prm = nil
 174         page = prm.to_i
 175         page = 1 if page < 1
 176         page
 177       end
 178
 179       def page_size prm
 180         page_size = prm.to_i
 181         page_size = @max_page_size if page_size > @max_page_size
 182         page_size = @default_page_size if page_size < 1
 183         page_size
 184       end
 185
 186       def where parent_item
 187         w = @model.list_where
 188         w += ' and ' unless w.blank?
 189         [w + @association_model_name + '.' + @foreign_key + ' = ?', parent_item.id]
 190       end
 191
 192       def items parent_item
 193         @model.where(self.where(parent_item)).includes(@model.list_opt).order(@model.list_order).offset(@offset).limit(@page_size)
 194       end
 195
 196       def paginate parent_item
 197         Kaminari.paginate_array(Array.new(@model.where(self.where(parent_item)).includes(@model.list_opt).count, nil)).page(@offset).per(@page_size)
 198       end
 199
 200     end
 201
 202     class FilterList
 203       def initialize page, page_size, operators, item_name, list_name, conf, manifest
 204         @operators = operators
 205         @item_name = item_name
 206         @list_name = list_name
 207         @conf = conf
 208         @manifest = manifest
 209         @default_page_size = @conf['default_page_size'] || 25
 210         @max_page_size = @conf['max_page_size'] || 100
 211         @page = self.page_number(page)
 212         @page_size = self.page_size page_size
 213
 214         @model = @item_name.classify.constantize
 215         @table_name = @model.table_name
 216         @offset = (@page -1) * @page_size
 217         @list_list_conf = @manifest.list(@item_name).lists[list_name] || {}
 218         @from = @list_list_conf['from']
 219         @filter_key = @list_list_conf['filter_key']
 220       end
 221
 222       def page_number prm = nil
 223         page = prm.to_i
 224         page = 1 if page < 1
 225         page
 226       end
 227
 228       def page_size prm
 229         page_size = prm.to_i
 230         page_size = @max_page_size if page_size > @max_page_size
 231         page_size = @default_page_size if page_size < 1
 232         page_size
 233       end
 234
 235       def list_opt
 236         {@from => {} }
 237       end
 238
 239       def where filter_item
 240         w = @model.list_where
 241         w += ' and ' unless w.blank?
 242         [w + @table_name + '.' + @filter_key + ' = ?', filter_item.id]
 243       end
 244
 245       def items filter_item
 246         @model.where(self.where(filter_item)).includes(self.list_opt).order(@model.list_order).offset(@offset).limit(@page_size)
 247       end
 248
 249       def paginate filter_item
 250         Kaminari.paginate_array(Array.new(@model.where(self.where(filter_item)).includes(self.list_opt).count, nil)).page(@offset).per(@page_size)
 251       end
 252
 253     end
 254
 255     class ThroughFilterList
 256       def initialize page, page_size, operators, item_name, list_name, conf, manifest
 257         @operators = operators
 258         @item_name = item_name
 259         @list_name = list_name
 260         @conf = conf
 261         @manifest = manifest
 262         @default_page_size = @conf['default_page_size'] || 25
 263         @max_page_size = @conf['max_page_size'] || 100
 264         @page = self.page_number(page)
 265         @page_size = self.page_size page_size
 266
 267         @model = @item_name.classify.constantize
 268         @table_name = @model.table_name
 269         @offset = (@page -1) * @page_size
 270         @list_list_conf = @manifest.list(@item_name).lists[list_name] || {}
 271         @filter_key = @list_list_conf['filter_key']
 272         @from = @list_list_conf['from']
 273         @through = @list_list_conf['through']
 274       end
 275
 276       def page_number prm = nil
 277         page = prm.to_i
 278         page = 1 if page < 1
 279         page
 280       end
 281
 282       def page_size prm
 283         page_size = prm.to_i
 284         page_size = @max_page_size if page_size > @max_page_size
 285         page_size = @default_page_size if page_size < 1
 286         page_size
 287       end
 288
 289       def list_opt
 290         {@through => {@from => {}} }
 291       end
 292
 293       def where filter_item
 294         w = @model.list_where
 295         w += ' and ' unless w.blank?
 296         [w + @through + '.' + @filter_key + ' = ?', filter_item.id]
 297       end
 298
 299       def items filter_item
 300         @model.where(self.where(filter_item)).includes(self.list_opt).order(@model.list_order).offset(@offset).limit(@page_size)
 301       end
 302
 303       def paginate filter_item
 304         Kaminari.paginate_array(Array.new(@model.where(self.where(filter_item)).includes(self.list_opt).count, nil)).page(@offset).per(@page_size)
 305       end
 306
 307     end
 308
 309     @@types = {'public' => PublicList, 'system_resource' => SystemResourceList, 'private' => PrivateList, 'has_many' => HasManyList, 'filter' => FilterList, 'through_filter' => ThroughFilterList}
 310     def initialize list_manifest
 311       @list_manifest = list_manifest
 312       @item_name = @list_manifest.item_name
 313       @manifest = @list_manifest.manifest
 314       @list_conf = @list_manifest.conf
 315       @lists = {}
 316       @list_manifest.lists.each {|list_name, conf|
 317         type = conf['type']
 318         @lists[list_name] = @@types[type]
 319       }
 320     end
 321
 322     def open list_name, page, page_size, operators
 323       @lists[list_name].new page, page_size, operators, @item_name, list_name, @list_conf, @manifest
 324     end
 325
 326   end
 327 end
 328