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 => true
  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 self.visible_count
 203     Panel.count
 204   end
 205
 206   def self.collect_element_value elements, name
 207     elements.map {|e|
 208       e.map {|o|
 209         o[name]
 210       }
 211     }.flatten
 212   end
 213
 214   def self.validate_t ary
 215     i = 0
 216     ary.compact.sort.each do |t|
 217       break false unless t == i
 218       i += 1
 219     end
 220     ary.compact.size == i
 221   end
 222
 223   def self.validate_element_t elements, name
 224     Panel.validate_t(Panel.collect_element_value(elements, name))
 225   end
 226
 227   def self.validate_elements_t c
 228     c.map {|conf|
 229       Panel.validate_element_t(conf[:elements], conf[:name]) ? nil : false
 230     }.compact.empty?
 231   end
 232
 233   def validate_t_list
 234     [
 235       {:elements => [self.panel_pictures, self.speech_balloons], :name => :t}
 236     ]
 237   end
 238   def validate_child
 239 #    r1 = Panel.validate_elements_id validate_id_list
 240     Panel.validate_elements_t validate_t_list
 241   end
 242
 243   def store attr, au
 244     if attr == false
 245       self.errors.add :base, 'invalid json'
 246       return false
 247     end
 248     self.attributes = attr
 249     self.overwrite au
 250     res = false
 251     Panel.transaction do
 252       unless validate_child
 253         self.errors.add :base , 'invalid time'
 254         raise ActiveRecord::Rollback
 255       end
 256       res = self.save
 257     end
 258     res
 259   end
 260
 261 =begin\r
 262   def self.validate_id ary, pid
 263     ary.map {|v|
 264       if pid
 265         (v == pid or v == nil) ? nil : false
 266       else
 267         v ? false : nil
 268       end
 269     }.compact.empty?
 270   end
 271
 272   def self.validate_element_id elements, name, pid
 273     Panel.validate_id(Panel.collect_element_value(elements, name), pid)
 274   end
 275
 276   def self.validate_elements_id c
 277     c.map {|conf|
 278       Panel.validate_element_id(conf[:elements], conf[:name], conf[:parent_id]) ? nil : false
 279     }.compact.empty?
 280   end
 281
 282   def validate_id_list
 283     r = self.speech_balloons.map {|sb|
 284       {:elements => [sb.speeches, sb.balloons], :name => :speech_balloon_id, :parent_id => sb.id}
 285     }
 286     r.unshift({:elements => [self.panel_pictures, self.speech_balloons], :name => :panel_id, :parent_id => self.id})
 287     r
 288   end
 289 =end
 290
 291 end