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   has_many :panel_colors, :dependent => :destroy
  11   accepts_nested_attributes_for :panel_pictures, :allow_destroy => true
  12   accepts_nested_attributes_for :speech_balloons, :allow_destroy => true
  13   accepts_nested_attributes_for :ground_pictures, :allow_destroy => true
  14   accepts_nested_attributes_for :ground_colors, :allow_destroy => true
  15   accepts_nested_attributes_for :panel_colors, :allow_destroy => true
  16
  17   validates :width, :presence => true, :numericality => true, :natural_number => true
  18   validates :height, :presence => true, :numericality => true, :natural_number => true
  19   validates :border, :presence => true, :numericality => {:greater_than_or_equal_to => 0}
  20   validates :x, :numericality => {:allow_blank => true}
  21   validates :y, :numericality => {:allow_blank => true}
  22   validates :z, :numericality => {:allow_blank => true, :greater_than => 0}
  23   validates :author_id, :presence => true, :numericality => true, :existence => {:both => false}
  24   validates :publish, :presence => true, :numericality => true
  25
  26   before_validation :valid_encode
  27
  28   def valid_encode
  29     ['caption'].each do |a|
  30       next if attributes[a] == nil
  31       raise Pettanr::BadRequest unless attributes[a].valid_encoding?
  32     end
  33   end
  34
  35   def supply_default
  36     self.border = 2
  37     self.publish = 0
  38   end
  39
  40   def overwrite au
  41     self.author_id = au.id
  42   end
  43
  44   def own? roles
  45     roles = [roles] unless roles.respond_to?(:each)
  46     au = Panel.get_author_from_roles roles
  47     return false unless au
  48     self.author_id == au.id
  49   end
  50
  51   def visible? roles
  52     if MagicNumber['run_mode'] == 0
  53       return false unless guest_role_check(roles)
  54     else
  55       return false unless reader_role_check(roles)
  56     end
  57     return true if self.own?(roles)
  58     self.publish?
  59   end
  60
  61   def usable? au
  62     visible? au
  63   end
  64
  65   def publish?
  66     self.publish > 0
  67   end
  68
  69   def self.default_page_size
  70     25
  71   end
  72
  73   def self.max_page_size
  74     100
  75   end
  76
  77   def self.page prm = nil
  78     page = prm.to_i
  79     page = 1 if page < 1
  80     page
  81   end
  82
  83   def self.page_size prm = self.default_page_size
  84     page_size = prm.to_i
  85     page_size = self.max_page_size if page_size > self.max_page_size
  86     page_size = self.default_page_size if page_size < 1
  87     page_size
  88   end
  89
  90   def self.list page = 1, page_size = self.default_page_size
  91     opt = {}
  92     opt.merge!(self.list_opt)
  93     opt.merge!({:limit => page_size, :offset => (page -1) * page_size}) if page_size > 0
  94     opt.merge!({:conditions => 'panels.publish > 0', :order => 'panels.updated_at desc'})
  95     Panel.find(:all, opt)
  96   end
  97
  98   def self.mylist au, page = 1, page_size = Author.default_panel_page_size
  99     opt = {}
 100     opt.merge!(self.list_opt)
 101     opt.merge!({:limit => page_size, :offset => (page -1) * page_size}) if page_size > 0
 102     opt.merge!({:conditions => ['panels.author_id = ?', au.id], :order => 'panels.updated_at desc'})
 103     Panel.find(:all, opt)
 104   end
 105
 106   def self.himlist au, page = 1, page_size = Author.default_panel_page_size
 107     opt = {}
 108     opt.merge!(self.list_opt)
 109     opt.merge!({:limit => page_size, :offset => (page -1) * page_size}) if page_size > 0
 110     opt.merge!({:conditions => ['panels.author_id = ? and panels.publish > 0', au.id], :order => 'panels.updated_at desc'})
 111     Panel.find(:all, opt)
 112   end
 113
 114   def self.list_opt
 115     {:include => {
 116       :panel_pictures => {
 117         :picture => {:artist => {}, :license => {}}
 118       },
 119       :speech_balloons => {:balloons => {}, :speeches => {}},
 120       :ground_pictures => {
 121         :picture => {:artist => {}, :license => {}}
 122       },
 123       :ground_colors => {
 124         :color => {}
 125       },
 126       :panel_colors => {
 127       },
 128       :author => {}
 129     }}
 130   end
 131
 132   def self.show rid, roles
 133     opt = {}
 134     opt.merge!(Panel.show_opt)
 135     res = Panel.find(rid, opt)
 136     raise ActiveRecord::Forbidden unless res.visible?(roles)
 137     res
 138   end
 139
 140   def self.edit rid, au
 141     opt = {}
 142     opt.merge!(Panel.show_opt)
 143     res = Panel.find(rid, opt)
 144     raise ActiveRecord::Forbidden unless res.own?(au)
 145     res
 146   end
 147
 148   def self.show_opt
 149     {:include => {
 150       :panel_pictures => {
 151         :picture => {:artist => {}, :license => {}}
 152       },
 153       :speech_balloons => {:balloons => {}, :speeches => {}},
 154       :ground_pictures => {
 155         :picture => {:artist => {}, :license => {}}
 156       },
 157       :ground_colors => {
 158         :color => {}
 159       },
 160       :panel_colors => {
 161       },
 162       :author => {}
 163     }}
 164   end
 165
 166   def parts_element
 167     ((self.panel_pictures || []) + (self.speech_balloons || [])).compact
 168   end
 169
 170   def parts
 171     res = []
 172     self.parts_element.each do |e|
 173       res[e.t] = e
 174     end
 175     res
 176   end
 177
 178   def grounds
 179     ((self.ground_colors || []) + (self.ground_pictures || []) + (self.panel_colors || [])).compact
 180   end
 181
 182   def panel_elements
 183     parts + grounds
 184   end
 185
 186   @@elm_json_opt = {
 187     'PanelPicture' => {
 188       :picture => {:artist => {}, :license => {}}
 189     },
 190     'SpeechBalloon' => {:balloons => {}, :speeches => {}},
 191     'GroundPicture' => {
 192       :picture => {:artist => {}, :license => {}}
 193     },
 194     'GroundColor' => {
 195       :color => {}
 196     },
 197     'PanelColor' => {
 198     }
 199   }
 200
 201   def self.elm_json_opt e
 202     @@elm_json_opt[e.class.to_s]
 203   end
 204
 205   def elements
 206     self.panel_elements.map {|e|
 207       #(-_-;)<... kore wa hidoi
 208       JSON.parse e.to_json({:include => Panel.elm_json_opt(e)})
 209     }
 210   end
 211
 212   def panel_elements_as_json
 213     self.to_json({:include => {:author => {}}, :methods => :elements})
 214   end
 215
 216   def self.list_as_json_text ary
 217     '[' + ary.map {|i| i.panel_elements_as_json }.join(',') + ']'
 218   end
 219
 220   def scenario
 221     panel_elements.map { |e|
 222       e.scenario
 223     }.join
 224   end
 225
 226   def plain_scenario
 227     panel_elements.map { |e|
 228       e.plain_scenario
 229     }.join
 230   end
 231
 232   def licensed_pictures
 233     r = {}
 234     ((self.panel_pictures || []) + (self.ground_pictures || [])).compact.each do |elm|
 235       r[elm.picture_id] = elm.picture unless r[elm.picture_id]
 236     end
 237     r
 238   end
 239
 240   def self.visible_count
 241     Panel.count
 242   end
 243
 244   def self.collect_element_value elements, name
 245     elements.map {|e|
 246       e.map {|o|
 247         o[name]
 248       }
 249     }.flatten
 250   end
 251
 252   def self.validate_t ary
 253     i = 0
 254     ary.compact.sort.each do |t|
 255       break false unless t == i
 256       i += 1
 257     end
 258     ary.compact.size == i
 259   end
 260
 261   def self.validate_element_t elements, name
 262     Panel.validate_t(Panel.collect_element_value(elements, name))
 263   end
 264
 265   def self.validate_elements_t c
 266     c.map {|conf|
 267       Panel.validate_element_t(conf[:elements], conf[:name]) ? nil : false
 268     }.compact.empty?
 269   end
 270
 271   def validate_t_list
 272     [
 273       {:elements => [self.panel_pictures, self.speech_balloons], :name => :t}
 274     ]
 275   end
 276   def validate_child
 277 #    r1 = Panel.validate_elements_id validate_id_list
 278     Panel.validate_elements_t validate_t_list
 279   end
 280
 281   def store attr, au
 282     if attr == false
 283       self.errors.add :base, I18n.t('errors.invalid_json')
 284       return false
 285     end
 286     self.attributes = attr
 287     self.overwrite au
 288     res = false
 289     Panel.transaction do
 290       unless validate_child
 291         self.errors.add :base, I18n.t('errors.invalid_t')
 292         raise ActiveRecord::Rollback
 293       end
 294       res = self.save
 295     end
 296     res
 297   end
 298
 299   def destroy_with_elements
 300     res = false
 301     Panel.transaction do
 302       self.panel_elements.each do |element|
 303         raise ActiveRecord::Rollback unless element.destroy
 304       end
 305       raise ActiveRecord::Rollback unless self.destroy
 306       res = true
 307     end
 308     res
 309   end
 310
 311 =begin
 312   def self.validate_id ary, pid
 313     ary.map {|v|
 314       if pid
 315         (v == pid or v == nil) ? nil : false
 316       else
 317         v ? false : nil
 318       end
 319     }.compact.empty?
 320   end
 321
 322   def self.validate_element_id elements, name, pid
 323     Panel.validate_id(Panel.collect_element_value(elements, name), pid)
 324   end
 325
 326   def self.validate_elements_id c
 327     c.map {|conf|
 328       Panel.validate_element_id(conf[:elements], conf[:name], conf[:parent_id]) ? nil : false
 329     }.compact.empty?
 330   end
 331
 332   def validate_id_list
 333     r = self.speech_balloons.map {|sb|
 334       {:elements => [sb.speeches, sb.balloons], :name => :speech_balloon_id, :parent_id => sb.id}
 335     }
 336     r.unshift({:elements => [self.panel_pictures, self.speech_balloons], :name => :panel_id, :parent_id => self.id})
 337     r
 338   end
 339 =end
 340
 341 end