app/models/sheet.rb

   1 class Sheet < Pettanr::Item
   2   has_many :sheet_panels
   3   has_many :story_sheets
   4   belongs_to :author
   5
   6   validates :caption, :presence => true, :length => {:maximum => 100}
   7   validates :width, :presence => true, :numericality => true, :natural_number => true
   8   validates :height, :presence => true, :numericality => true, :natural_number => true
   9   validates :visible, :presence => true, :numericality => true, :inclusion => {:in => 0..1}
  10   accepts_nested_attributes_for :sheet_panels, :allow_destroy => true
  11
  12   def self.singular
  13     'Sheet'
  14   end
  15
  16   def self.plural
  17     'Sheets'
  18   end
  19
  20   def self.owner_type
  21     :author
  22   end
  23
  24   def self.valid_encode_columns
  25     super.merge ['caption']
  26   end
  27
  28   def self.each_element_class_names
  29     {'SheetPanel' => 'sheet_panels'}.each do |k, n|
  30       yield k
  31     end
  32   end
  33
  34   def self.class_name_to_class k
  35     Object.const_get k
  36   end
  37
  38   def self.each_element_classes
  39     self.each_element_class_names do |k|
  40       e = self.class_name_to_class k
  41       yield e
  42     end
  43   end
  44
  45   def elements_by_class_name class_name
  46     self.__send__ class_name.tableize
  47   end
  48
  49   def supply_default
  50     self.visible = 0 if self.visible.blank?
  51   end
  52
  53   def overwrite au
  54     return false unless au
  55     self.author_id = au.id
  56   end
  57
  58   def own? roles
  59     roles = [roles] unless roles.respond_to?(:each)
  60     au = Sheet.get_author_from_roles roles
  61     return false unless au
  62     self.author_id == au.id
  63   end
  64
  65   def visible? roles
  66     if MagicNumber['run_mode'] == 0
  67       return false unless guest_role_check(roles)
  68     else
  69       return false unless reader_role_check(roles)
  70     end
  71     return true if self.own?(roles)
  72     return true if self.new_record?
  73     self.visible > 0
  74   end
  75
  76   def usable? au
  77     visible? au
  78   end
  79
  80   def symbol_filename
  81   end
  82
  83   def tag_id
  84     'sheet' + self.tag_sheet_id
  85   end
  86
  87   def tag_sheet_id
  88     self.new_record? ? '0' : self.id.to_s
  89   end
  90
  91   def field_tag_id f
  92     self.tag_id + f.to_s
  93   end
  94
  95   def self.default_page_size
  96     25
  97   end
  98
  99   def self.max_page_size
 100     100
 101   end
 102
 103   def self.default_panel_size
 104     30
 105   end
 106
 107   def self.max_panel_size
 108     200
 109   end
 110
 111   def self.page prm = nil
 112     page = prm.to_i
 113     page = 1 if page < 1
 114     page
 115   end
 116
 117   def self.page_size prm = self.default_page_size
 118     page_size = prm.to_i
 119     page_size = self.max_page_size if page_size > self.max_page_size
 120     page_size = self.default_page_size if page_size < 1
 121     page_size
 122   end
 123
 124   def self.list_where
 125     'sheets.visible > 0'
 126   end
 127
 128   def self.mylist_where au
 129     ['sheets.author_id = ?', au.id]
 130   end
 131
 132   def self.himlist_where au
 133     ['sheets.author_id = ? and sheets.visible > 0', au.id]
 134   end
 135
 136   def self.list page = 1, page_size = self.default_page_size
 137     Sheet.where(self.list_where()).includes(Sheet.list_opt).order('sheets.updated_at desc').offset((page -1) * page_size).limit(page_size)
 138   end
 139
 140   def self.mylist au, page = 1, page_size = Author.default_sheet_page_size
 141     Sheet.where(self.mylist_where(au)).includes(Sheet.list_opt).order('sheets.updated_at desc').offset((page -1) * page_size).limit(page_size)
 142   end
 143
 144   def self.himlist au, page = 1, page_size = Author.default_sheet_page_size
 145     Sheet.where(self.himlist_where(au)).includes(Sheet.list_opt).order('sheets.updated_at desc').offset((page -1) * page_size).limit(page_size)
 146   end
 147
 148   def self.list_paginate page = 1, page_size = self.default_page_size
 149     Kaminari.paginate_array(Array.new(Sheet.where(self.list_where()).count, nil)).page(page).per(page_size)
 150   end
 151
 152   def self.mylist_paginate au, page = 1, page_size = Author.default_sheet_page_size
 153     Kaminari.paginate_array(Array.new(Sheet.where(self.mylist_where(au)).count, nil)).page(page).per(page_size)
 154   end
 155
 156   def self.himlist_paginate au, page = 1, page_size = Author.default_sheet_page_size
 157     Kaminari.paginate_array(Array.new(Sheet.where(self.himlist_where(au)).count, nil)).page(page).per(page_size)
 158   end
 159
 160   def self.list_by_story story_id, roles, page = 1, page_size = self.default_page_size
 161     self.where(StorySheet.list_by_story_where(story_id)).includes(
 162       {:story_sheets => {}}
 163     ).order('story_sheets.updated_at desc').offset((page -1) * page_size).limit(page_size)
 164   end
 165
 166   def self.list_by_panel panel_id, roles, page = 1, page_size = self.default_page_size
 167     self.where(SheetPanel.list_by_panel_where(panel_id)).includes(
 168       {:sheet_panels => {}}
 169     ).order('sheet_panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
 170   end
 171
 172   def self.list_by_author_where author_id
 173     ['sheets.author_id = ?', author_id]
 174   end
 175
 176   def self.list_by_author author_id, roles, page = 1, page_size = self.default_page_size
 177     self.where(self.list_by_author_where(author_id)).includes(self.list_opt).order('sheets.updated_at desc').offset((page -1) * page_size).limit(page_size)
 178   end
 179
 180   def self.list_opt
 181     {:sheet_panels => {:panel => {}}, :author => {} }
 182   end
 183
 184   def self.list_json_opt
 185     {:include => {:sheet_panels => {:include => {:panel => {}}}, :author => {}}}
 186   end
 187
 188   def self.show sid, roles
 189     opt = {}
 190     opt.merge!(Sheet.show_opt)
 191     res = Sheet.find(sid, opt)
 192     raise ActiveRecord::Forbidden unless res.visible?(roles)
 193     res
 194   end
 195
 196   def self.edit sid, au
 197     opt = {}
 198     opt.merge!(Sheet.show_opt)
 199     res = Sheet.find(sid, opt)
 200     raise ActiveRecord::Forbidden unless res.own?(au)
 201     res
 202   end
 203
 204   def self.show_opt
 205     {:include => {:sheet_panels => {:panel => {}}, :author => {}}}
 206   end
 207
 208   def self.show_json_opt
 209     {:include => {:sheet_panels => {:include => {:panel => {}}}, :author => {}}}
 210   end
 211
 212   def parts_element
 213     r = []
 214     self.class.each_element_class_names do |k|
 215       r += (self.elements_by_class_name(k) || [])
 216     end
 217     r
 218   end
 219
 220   def zorderd_elements
 221     res = []
 222     self.parts_element.each do |e|
 223       res[e.z-1] = e
 224     end
 225     res
 226   end
 227
 228   def sheet_elements
 229     res = []
 230     self.parts_element.each do |e|
 231       res[e.t] = e
 232     end
 233     res
 234   end
 235
 236   def new_t
 237     self.sheet_elements.size
 238   end
 239
 240   def new_z
 241     self.sheet_elements.size + 1
 242   end
 243
 244   def self.visible_count
 245     Sheet.count 'visible > 0'
 246   end
 247
 248   def self.collect_element_value elements, name
 249     elements.map {|e|
 250       e.map {|o|
 251         if o['_destroy'] or o[:_destroy]
 252           nil
 253         else
 254           o[name]
 255         end
 256       }.compact
 257     }.flatten
 258   end
 259
 260   def self.validate_serial ary, offset = 0
 261     i = offset
 262     ary.compact.sort.each do |n|
 263       break false unless n == i
 264       i += 1
 265     end
 266     ary.compact.size == i - offset
 267   end
 268
 269   def self.validate_element_serial elements, name, offset = 0
 270     Sheet.validate_serial(Sheet.collect_element_value(elements, name), offset)
 271   end
 272
 273   def self.validate_elements_serial c
 274     c.map {|conf|
 275       Sheet.validate_element_serial(conf[:elements], conf[:name], conf[:offset]) ? nil : false
 276     }.compact.empty?
 277   end
 278
 279   def validate_serial_list
 280     l = []
 281     self.class.each_element_class_names do |k|
 282       l << self.elements_by_class_name(k)
 283     end
 284 #    l = [self.sheet_panels]
 285     [
 286       {:elements => l, :name => :t, :offset => 0},
 287       {:elements => l, :name => :z, :offset => 1}
 288     ]
 289   end
 290
 291   def validate_child
 292 #    r1 = Panel.validate_elements_id validate_id_list
 293     Sheet.validate_elements_serial validate_serial_list
 294   end
 295
 296   def boost
 297     @new_element_index = 0
 298     self.panel_elements.each do |elm|
 299       if elm.new_record?
 300         elm.new_index = @new_element_index
 301         @new_element_index += 1
 302       end
 303     end
 304   end
 305
 306   def store attr, au
 307     if attr == false
 308       self.errors.add :base, I18n.t('errors.invalid_json')
 309       return false
 310     end
 311     self.attributes = attr
 312     self.overwrite au
 313     res = false
 314     Sheet.transaction do
 315       self.sheet_elements.each do |elm|
 316         elm.new_sheet = self
 317         elm.boost au
 318       end
 319       res = self.save
 320       unless validate_child
 321         res = false
 322         self.errors.add :base, I18n.t('errors.invalid_t')
 323         raise ActiveRecord::Rollback
 324       end
 325     end
 326     res
 327   end
 328
 329   def destroy_with_sheet_panel
 330     res = false
 331     Sheet.transaction do
 332       self.sheet_panels.each do |sheet_panel|
 333         raise ActiveRecord::Rollback unless sheet_panel.destroy
 334       end
 335       raise ActiveRecord::Rollback unless self.destroy
 336       res = true
 337     end
 338     res
 339   end
 340
 341   def scenario
 342     panels.map {|panel|
 343       panel.scenario
 344     }.join
 345   end
 346
 347   def plain_scenario
 348     panels.map {|panel|
 349       panel.plain_scenario
 350     }.join
 351   end
 352
 353   def licensed_pictures
 354     r = {}
 355     self.sheet_elements.each do |elm|
 356       r.merge!(elm.licensed_pictures)
 357     end
 358     r
 359   end
 360
 361   def copyable?
 362     r = true
 363     Sheet.each_element_class_names do |n|
 364       self.elements_by_class_name(n).each do |elm|
 365         next if elm.copyable?
 366         r = false
 367         break
 368       end
 369       break unless r
 370     end
 371     r
 372   end
 373
 374   def copy
 375     attr = self.copy_attributes
 376     Sheet.each_element_class_names do |n|
 377       element_attr = Sheet.class_name_to_class(n).panelize(
 378         self.elements_by_class_name(n).map {|elm|
 379           elm.copy_attributes.merge elm.panel_attributes
 380         }
 381       )
 382       attr.merge! element_attr
 383     end
 384     attr
 385   end
 386
 387   def copy_attributes
 388     r = self.attributes
 389     r.delete 'id'
 390     r.delete 'author_id'
 391     r.delete 'created_at'
 392     r.delete 'updated_at'
 393     r
 394   end
 395
 396   def self.panelize sheet
 397     attr = sheet.attributes
 398     attr.delete 'id'
 399     attr
 400   end
 401
 402 end