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