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