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