app/models/panel.rb

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