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_where
  89     'panels.publish > 0'
  90   end
  91
  92   def self.mylist_where au
  93     ['panels.author_id = ?', au.id]
  94   end
  95
  96   def self.himlist_where au
  97     ['panels.author_id = ? and panels.publish > 0', au.id]
  98   end
  99
 100   def self.list page = 1, page_size = self.default_page_size
 101     Panel.where(self.list_where()).includes(Panel.list_opt).order('panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
 102   end
 103
 104   def self.mylist au, page = 1, page_size = Author.default_panel_page_size
 105     Panel.where(self.mylist_where(au)).includes(Panel.list_opt).order('panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
 106   end
 107
 108   def self.himlist au, page = 1, page_size = Author.default_panel_page_size
 109     Panel.where(self.himlist_where(au)).includes(Panel.list_opt).order('panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
 110   end
 111
 112   def self.list_paginate page = 1, page_size = self.default_page_size
 113     Kaminari.paginate_array(Array.new(Panel.where(self.list_where()).count, nil)).page(page).per(page_size)
 114   end
 115
 116   def self.mylist_paginate au, page = 1, page_size = Author.default_panel_page_size
 117     Kaminari.paginate_array(Array.new(Panel.where(self.mylist_where(au)).count, nil)).page(page).per(page_size)
 118   end
 119
 120   def self.himlist_paginate au, page = 1, page_size = Author.default_panel_page_size
 121     Kaminari.paginate_array(Array.new(Panel.where(self.himlist_where(au)).count, nil)).page(page).per(page_size)
 122   end
 123
 124   def self.list_opt
 125     {
 126       :panel_pictures => {
 127         :picture => {:artist => {}, :license => {}}
 128       },
 129       :speech_balloons => {:balloon => {}, :speech => {}},
 130       :ground_pictures => {
 131         :picture => {:artist => {}, :license => {}}
 132       },
 133       :ground_colors => {
 134       },
 135       :author => {}
 136     }
 137   end
 138
 139   def self.show rid, roles
 140     opt = {}
 141     opt.merge!(Panel.show_opt)
 142     res = Panel.find(rid, opt)
 143     raise ActiveRecord::Forbidden unless res.visible?(roles)
 144     res
 145   end
 146
 147   def self.edit rid, au
 148     opt = {}
 149     opt.merge!(Panel.show_opt)
 150     res = Panel.find(rid, opt)
 151     raise ActiveRecord::Forbidden unless res.own?(au)
 152     res
 153   end
 154
 155   def self.show_opt
 156     {:include => {
 157       :panel_pictures => {
 158         :picture => {:artist => {}, :license => {}}
 159       },
 160       :speech_balloons => {:balloon => {}, :speech => {}},
 161       :ground_pictures => {
 162         :picture => {:artist => {}, :license => {}}
 163       },
 164       :ground_colors => {
 165       },
 166       :author => {}
 167     }}
 168   end
 169
 170   def parts_element
 171     ((self.panel_pictures || []) + (self.speech_balloons || []) + (self.ground_colors || []) + (self.ground_pictures || [])).compact
 172   end
 173
 174   def parts
 175     res = []
 176     self.parts_element.each do |e|
 177       res[e.t] = e
 178     end
 179     res
 180   end
 181
 182   def zorderd_elements
 183     res = []
 184     self.parts_element.each do |e|
 185       res[e.z-1] = e
 186     end
 187     res
 188   end
 189
 190   def panel_elements
 191     parts
 192   end
 193
 194   @@elm_json_opt = {
 195     'PanelPicture' => {
 196       :picture => {:artist => {}, :license => {}}
 197     },
 198     'SpeechBalloon' => {:balloon => {}, :speech => {}},
 199     'GroundPicture' => {
 200       :picture => {:artist => {}, :license => {}}
 201     },
 202     'GroundColor' => {
 203     },
 204   }
 205
 206   def self.elm_json_opt e
 207     @@elm_json_opt[e.class.to_s]
 208   end
 209
 210   def elements
 211     self.panel_elements.map {|e|
 212       #(-_-;)<... kore wa hidoi
 213       JSON.parse e.to_json({:include => Panel.elm_json_opt(e)})
 214     }
 215   end
 216
 217   def panel_elements_as_json
 218     self.to_json({:include => {:author => {}}, :methods => :elements})
 219   end
 220
 221   def self.list_as_json_text ary
 222     '[' + ary.map {|i| i.panel_elements_as_json }.join(',') + ']'
 223   end
 224
 225   def new_t
 226     self.parts.size
 227   end
 228
 229   def new_z
 230     self.parts.size + 1
 231   end
 232
 233   def scenario
 234     panel_elements.map { |e|
 235       e.scenario
 236     }.join
 237   end
 238
 239   def plain_scenario
 240     panel_elements.map { |e|
 241       e.plain_scenario
 242     }.join
 243   end
 244
 245   def licensed_pictures
 246     r = {}
 247     ((self.panel_pictures || []) + (self.ground_pictures || [])).compact.each do |elm|
 248       r[elm.picture_id] = elm.picture unless r[elm.picture_id]
 249     end
 250     r
 251   end
 252
 253   def self.visible_count
 254     Panel.count
 255   end
 256
 257   def self.collect_element_value elements, name
 258     elements.map {|e|
 259       e.map {|o|
 260         if o['_destroy'] or o[:_destroy]
 261           nil
 262         else
 263           o[name]
 264         end
 265       }.compact
 266     }.flatten
 267   end
 268
 269   def self.validate_serial ary, offset = 0
 270     i = offset
 271     ary.compact.sort.each do |n|
 272       break false unless n == i
 273       i += 1
 274     end
 275     ary.compact.size == i - offset
 276   end
 277
 278   def self.validate_element_serial elements, name, offset = 0
 279     Panel.validate_serial(Panel.collect_element_value(elements, name), offset)
 280   end
 281
 282   def self.validate_elements_serial c
 283     c.map {|conf|
 284       Panel.validate_element_serial(conf[:elements], conf[:name], conf[:offset]) ? nil : false
 285     }.compact.empty?
 286   end
 287
 288   def validate_serial_list
 289     [
 290       {:elements => [self.panel_pictures, self.speech_balloons, self.ground_colors, self.ground_pictures], :name => :t, :offset => 0},
 291       {:elements => [self.panel_pictures, self.speech_balloons, self.ground_colors, self.ground_pictures], :name => :z, :offset => 1}
 292     ]
 293   end
 294   def validate_child
 295 #    r1 = Panel.validate_elements_id validate_id_list
 296     Panel.validate_elements_serial validate_serial_list
 297   end
 298
 299   def store attr, au
 300     if attr == false
 301       self.errors.add :base, I18n.t('errors.invalid_json')
 302       return false
 303     end
 304     self.attributes = attr
 305     self.overwrite au
 306     res = false
 307     Panel.transaction do
 308       res = self.save
 309       unless validate_child
 310         res = false
 311         self.errors.add :base, I18n.t('errors.invalid_t')
 312         raise ActiveRecord::Rollback
 313       end
 314     end
 315     res
 316   end
 317
 318   def destroy_with_elements
 319     res = false
 320     Panel.transaction do
 321       self.parts_element.each do |element|
 322         raise ActiveRecord::Rollback unless element.destroy
 323       end
 324       raise ActiveRecord::Rollback unless self.destroy
 325       res = true
 326     end
 327     res
 328   end
 329
 330 =begin
 331   def self.validate_id ary, pid
 332     ary.map {|v|
 333       if pid
 334         (v == pid or v == nil) ? nil : false
 335       else
 336         v ? false : nil
 337       end
 338     }.compact.empty?
 339   end
 340
 341   def self.validate_element_id elements, name, pid
 342     Panel.validate_id(Panel.collect_element_value(elements, name), pid)
 343   end
 344
 345   def self.validate_elements_id c
 346     c.map {|conf|
 347       Panel.validate_element_id(conf[:elements], conf[:name], conf[:parent_id]) ? nil : false
 348     }.compact.empty?
 349   end
 350
 351   def validate_id_list
 352     r = self.speech_balloons.map {|sb|
 353       {:elements => [sb.speeches, sb.balloons], :name => :speech_balloon_id, :parent_id => sb.id}
 354     }
 355     r.unshift({:elements => [self.panel_pictures, self.speech_balloons], :name => :panel_id, :parent_id => self.id})
 356     r
 357   end
 358 =end
 359
 360 end