app/models/panel.rb

   1 #コマ
   2 class Panel < ActiveRecord::Base
   3   belongs_to :author
   4   has_many :scroll_panels
   5   has_many :sheet_panels
   6   has_many :panel_pictures, :dependent => :destroy
   7   has_many :speech_balloons, :dependent => :destroy
   8   has_many :ground_pictures, :dependent => :destroy
   9   has_many :ground_colors, :dependent => :destroy
  10   accepts_nested_attributes_for :panel_pictures, :allow_destroy => true
  11   accepts_nested_attributes_for :speech_balloons, :allow_destroy => true
  12   accepts_nested_attributes_for :ground_pictures, :allow_destroy => true
  13   accepts_nested_attributes_for :ground_colors, :allow_destroy => true
  14
  15   validates :width, :presence => true, :numericality => true, :natural_number => true
  16   validates :height, :presence => true, :numericality => true, :natural_number => true
  17   validates :border, :presence => true, :numericality => {:greater_than_or_equal_to => 0}
  18   validates :author_id, :presence => true, :numericality => true, :existence => {:both => false}
  19   validates :publish, :presence => true, :numericality => true
  20
  21   before_validation :valid_encode
  22
  23   def valid_encode
  24     ['caption'].each do |a|
  25       next if attributes[a] == nil
  26       raise Pettanr::BadRequest unless attributes[a].valid_encoding?
  27     end
  28   end
  29
  30   def self.each_element_class_names
  31     Pettanr::Application.elements.each do |k, n|
  32       yield k
  33     end
  34   end
  35
  36   def self.class_name_to_class k
  37     Object.const_get k
  38   end
  39
  40   def self.each_element_classes
  41     self.each_element_class_names do |k|
  42       e = self.class_name_to_class k
  43       yield e
  44     end
  45   end
  46
  47   def elements_by_class_name class_name
  48     self.__send__ class_name.tableize
  49   end
  50
  51   def supply_default
  52     self.border = 2
  53     self.publish = 0
  54   end
  55
  56   def overwrite au
  57     self.author_id = au.id
  58   end
  59
  60   def own? roles
  61     roles = [roles] unless roles.respond_to?(:each)
  62     au = Panel.get_author_from_roles roles
  63     return false unless au
  64     self.author_id == au.id
  65   end
  66
  67   def visible? roles
  68     if MagicNumber['run_mode'] == 0
  69       return false unless guest_role_check(roles)
  70     else
  71       return false unless reader_role_check(roles)
  72     end
  73     return true if self.own?(roles)
  74     return true if self.new_record?
  75     self.publish?
  76   end
  77
  78   def usable? au
  79     visible? au
  80   end
  81
  82   def publish?
  83     self.publish > 0
  84   end
  85
  86   def tag_id c = nil
  87     'panel' + self.tag_panel_id + c.to_s
  88   end
  89
  90   def tag_panel_id
  91     self.new_record? ? '0' : self.id.to_s
  92   end
  93
  94   def field_tag_id f
  95     self.tag_id + f.to_s
  96   end
  97
  98   def tag_attributes column = nil, opt = {}
  99     {
 100       :id => self.field_tag_id(column), :panel_id => self.tag_panel_id
 101     }.merge(opt)
 102   end
 103
 104   def select_tag_attributes(selected, column, opt = {})
 105     [
 106       :last, :first,
 107       {:html => {:selected => selected}},
 108       self.field_tag_attributes(column, opt)
 109     ]
 110   end
 111
 112   def field_tag_attributes column, opt = {}
 113     self.tag_attributes(column).merge(
 114       {:column => column}
 115     ).merge(opt)
 116   end
 117
 118   def tag_attr column = nil, opt = {}
 119     self.tag_attributes(column, opt).to_attr
 120   end
 121
 122   def field_tag_attr column, no_attr, opt = {}
 123     self.field_tag_attributes(column, no_attr, opt).to_attr
 124   end
 125
 126   def self.default_page_size
 127     25
 128   end
 129
 130   def self.max_page_size
 131     100
 132   end
 133
 134   def self.page prm = nil
 135     page = prm.to_i
 136     page = 1 if page < 1
 137     page
 138   end
 139
 140   def self.page_size prm = self.default_page_size
 141     page_size = prm.to_i
 142     page_size = self.max_page_size if page_size > self.max_page_size
 143     page_size = self.default_page_size if page_size < 1
 144     page_size
 145   end
 146
 147   def self.list_where
 148     'panels.publish > 0'
 149   end
 150
 151   def self.mylist_where au
 152     ['panels.author_id = ?', au.id]
 153   end
 154
 155   def self.himlist_where au
 156     ['panels.author_id = ? and panels.publish > 0', au.id]
 157   end
 158
 159   def self.list page = 1, page_size = self.default_page_size
 160     Panel.where(self.list_where()).includes(Panel.list_opt).order('panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
 161   end
 162
 163   def self.mylist au, page = 1, page_size = Author.default_panel_page_size
 164     Panel.where(self.mylist_where(au)).includes(Panel.list_opt).order('panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
 165   end
 166
 167   def self.himlist au, page = 1, page_size = Author.default_panel_page_size
 168     Panel.where(self.himlist_where(au)).includes(Panel.list_opt).order('panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
 169   end
 170
 171   def self.list_paginate page = 1, page_size = self.default_page_size
 172     Kaminari.paginate_array(Array.new(Panel.where(self.list_where()).count, nil)).page(page).per(page_size)
 173   end
 174
 175   def self.mylist_paginate au, page = 1, page_size = Author.default_panel_page_size
 176     Kaminari.paginate_array(Array.new(Panel.where(self.mylist_where(au)).count, nil)).page(page).per(page_size)
 177   end
 178
 179   def self.himlist_paginate au, page = 1, page_size = Author.default_panel_page_size
 180     Kaminari.paginate_array(Array.new(Panel.where(self.himlist_where(au)).count, nil)).page(page).per(page_size)
 181   end
 182
 183   def self.list_by_scroll scroll_id, roles, page = 1, page_size = self.default_page_size
 184     self.where(ScrollPanel.list_by_scroll_where(scroll_id)).includes(
 185       {:scroll_panels => {}}
 186     ).order('scroll_panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
 187   end
 188
 189   def self.list_by_sheet sheet_id, roles, page = 1, page_size = self.default_page_size
 190     self.where(SheetPanel.list_by_sheet_where(sheet_id)).includes(
 191       {:sheet_panels => {}}
 192     ).order('sheet_panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
 193   end
 194
 195   def self.list_by_speech_balloon_template speech_balloon_template_id, roles, page = 1, page_size = self.default_page_size
 196     self.where(SpeechBalloon.list_by_speech_balloon_template_where(speech_balloon_template_id)).includes(
 197       {:speech_balloons => {}}
 198     ).order('speech_balloons.updated_at desc').offset((page -1) * page_size).limit(page_size)
 199   end
 200
 201   def self.list_by_author_where author_id
 202     ['panels.author_id = ?', author_id]
 203   end
 204
 205   def self.list_by_author author_id, roles, page = 1, page_size = self.default_page_size
 206     self.where(self.list_by_author_where(author_id)).includes(self.list_opt).order('panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
 207   end
 208
 209   def self.list_opt
 210     r = {
 211       :author => {}
 212     }
 213     self.each_element_classes do |e|
 214       r.merge!(e.list_opt_for_panel)
 215     end
 216     r
 217   end
 218
 219   def self.show rid, roles
 220     opt = {}
 221     opt.merge!(Panel.show_opt)
 222     res = Panel.find(rid, opt)
 223     raise ActiveRecord::Forbidden unless res.visible?(roles)
 224     res
 225   end
 226
 227   def self.edit rid, au
 228     opt = {}
 229     opt.merge!(Panel.show_opt)
 230     res = Panel.find(rid, opt)
 231     raise ActiveRecord::Forbidden unless res.own?(au)
 232     res
 233   end
 234
 235   def self.show_opt
 236     r = {
 237       :author => {}
 238     }
 239     self.each_element_classes do |e|
 240       r.merge!(e.show_opt_for_panel)
 241     end
 242     {:include => r}
 243   end
 244
 245   def parts_element
 246     r = []
 247     self.class.each_element_class_names do |k|
 248       r += (self.elements_by_class_name(k) || [])
 249     end
 250     r
 251   end
 252
 253   def zorderd_elements
 254     res = []
 255     self.parts_element.each do |e|
 256       res[e.z-1] = e
 257     end
 258     res
 259   end
 260
 261   def panel_elements
 262     res = []
 263     self.parts_element.each do |e|
 264       res[e.t] = e
 265     end
 266     res
 267   end
 268
 269   def elements
 270     self.panel_elements.map {|e|
 271       #(-_-;)<... kore wa hidoi
 272       JSON.parse e.to_json({:include => e.class.json_opt_for_panel})
 273     }
 274   end
 275
 276   def panel_elements_as_json
 277     self.to_json({:include => {:author => {}}, :methods => :elements})
 278   end
 279
 280   def self.list_as_json_text ary
 281     '[' + ary.map {|i| i.panel_elements_as_json }.join(',') + ']'
 282   end
 283
 284   def new_t
 285     self.panel_elements.size
 286   end
 287
 288   def new_z
 289     self.panel_elements.size + 1
 290   end
 291
 292   def scenario
 293     panel_elements.map { |e|
 294       e.scenario
 295     }.join
 296   end
 297
 298   def plain_scenario
 299     panel_elements.map { |e|
 300       e.plain_scenario
 301     }.join
 302   end
 303
 304   def licensed_pictures
 305     r = {}
 306     self.panel_elements.each do |elm|
 307       next unless elm.class.has_picture?
 308       r[elm.picture_id] = elm.picture unless r[elm.picture_id]
 309     end
 310     r
 311   end
 312
 313   def self.visible_count
 314     Panel.count
 315   end
 316
 317   def self.collect_element_value elements, name
 318     elements.map {|e|
 319       e.map {|o|
 320         if o['_destroy'] or o[:_destroy]
 321           nil
 322         else
 323           o[name]
 324         end
 325       }.compact
 326     }.flatten
 327   end
 328
 329   def self.validate_serial ary, offset = 0
 330     i = offset
 331     ary.compact.sort.each do |n|
 332       break false unless n == i
 333       i += 1
 334     end
 335     ary.compact.size == i - offset
 336   end
 337
 338   def self.validate_element_serial elements, name, offset = 0
 339     Panel.validate_serial(Panel.collect_element_value(elements, name), offset)
 340   end
 341
 342   def self.validate_elements_serial c
 343     c.map {|conf|
 344       Panel.validate_element_serial(conf[:elements], conf[:name], conf[:offset]) ? nil : false
 345     }.compact.empty?
 346   end
 347
 348   def validate_serial_list
 349     l = []
 350     self.class.each_element_class_names do |k|
 351       l << self.elements_by_class_name(k)
 352     end
 353     [
 354       {:elements => l, :name => :t, :offset => 0},
 355       {:elements => l, :name => :z, :offset => 1}
 356     ]
 357   end
 358   def validate_child
 359 #    r1 = Panel.validate_elements_id validate_id_list
 360     Panel.validate_elements_serial validate_serial_list
 361   end
 362
 363   def boost
 364     @new_element_index = 0
 365     self.panel_elements.each do |elm|
 366       if elm.new_record?
 367         elm.new_index = @new_element_index
 368         @new_element_index += 1
 369       end
 370     end
 371   end
 372
 373   def store attr, au
 374     if attr == false
 375       self.errors.add :base, I18n.t('errors.invalid_json')
 376       return false
 377     end
 378     self.attributes = attr
 379     self.overwrite au
 380     res = false
 381     Panel.transaction do
 382       self.panel_elements.each do |elm|
 383         elm.new_panel = self
 384         elm.boost
 385       end
 386 #self.publish = nil
 387       res = self.save
 388       unless validate_child
 389         res = false
 390         self.errors.add :base, I18n.t('errors.invalid_t')
 391         raise ActiveRecord::Rollback
 392       end
 393     end
 394     res
 395   end
 396
 397   def remove_element target, au
 398     ct = target.t
 399     cz = target.z
 400     panel_attributes = {}
 401     self.panel_elements.each do |elm|
 402       attr = elm.attributes
 403       if elm == target
 404         attr['_destroy'] = true
 405       end
 406       if elm.t > ct
 407         attr['t']  -= 1
 408       end
 409       if elm.z > cz
 410         attr['z']  -= 1
 411       end
 412       panel_attributes[elm.class.to_s.tableize + '_attributes'] ||= {}
 413       panel_attributes[elm.class.to_s.tableize + '_attributes'][elm.id] = attr
 414     end
 415     self.store(panel_attributes, au)
 416   end
 417
 418   def destroy_with_elements
 419     res = false
 420     Panel.transaction do
 421       self.parts_element.each do |element|
 422         raise ActiveRecord::Rollback unless element.destroy
 423       end
 424       raise ActiveRecord::Rollback unless self.destroy
 425       res = true
 426     end
 427     res
 428   end
 429
 430   def copy
 431     attr = self.copy_attributes
 432     Panel.each_element_class_names do |n|
 433       attr.merge! Panel.class_name_to_class(n).panelize(self.elements_by_class_name(n).map {|elm|  elm.copy_attributes})
 434     end
 435     attr
 436   end
 437
 438   def copy_attributes
 439     r = self.attributes
 440     r.delete 'id'
 441     r.delete 'author_id'
 442     r.delete 'created_at'
 443     r.delete 'updated_at'
 444     r
 445   end
 446
 447   def self.panelize panel
 448     attr = panel.attributes
 449     attr.delete 'id'
 450     attr
 451   end
 452
 453
 454 =begin
 455   def self.validate_id ary, pid
 456     ary.map {|v|
 457       if pid
 458         (v == pid or v == nil) ? nil : false
 459       else
 460         v ? false : nil
 461       end
 462     }.compact.empty?
 463   end
 464
 465   def self.validate_element_id elements, name, pid
 466     Panel.validate_id(Panel.collect_element_value(elements, name), pid)
 467   end
 468
 469   def self.validate_elements_id c
 470     c.map {|conf|
 471       Panel.validate_element_id(conf[:elements], conf[:name], conf[:parent_id]) ? nil : false
 472     }.compact.empty?
 473   end
 474
 475   def validate_id_list
 476     r = self.speech_balloons.map {|sb|
 477       {:elements => [sb.speeches, sb.balloons], :name => :speech_balloon_id, :parent_id => sb.id}
 478     }
 479     r.unshift({:elements => [self.panel_pictures, self.speech_balloons], :name => :panel_id, :parent_id => self.id})
 480     r
 481   end
 482 =end
 483
 484 end