app/models/scroll_panel.rb

   1 class ScrollPanel < ActiveRecord::Base
   2   belongs_to :author
   3   belongs_to :panel
   4   belongs_to :scroll
   5
   6   validates :scroll_id, :presence => true, :numericality => true, :existence => {:both => false}
   7   validates :panel_id, :presence => true, :numericality => true, :existence => {:both => false}
   8   validates :author_id, :presence => true, :numericality => true, :existence => {:both => false}
   9   validates :t, :presence => true, :numericality => {:greater_than_or_equal_to => 0}
  10
  11   def supply_default
  12     self.scroll_id = nil
  13     self.panel_id = nil
  14     self.t = nil
  15   end
  16
  17   def overwrite au
  18     return false unless au
  19     self.author_id = au.id
  20   end
  21
  22   def own? roles
  23     roles = [roles] unless roles.respond_to?(:each)
  24     au = ScrollPanel.get_author_from_roles roles
  25     return false unless au
  26     self.author_id == au.id
  27   end
  28
  29   def visible? roles
  30     if MagicNumber['run_mode'] == 0
  31       return false unless guest_role_check(roles)
  32     else
  33       return false unless reader_role_check(roles)
  34     end
  35     return true if self.scroll.own?(roles)
  36     self.scroll.visible? roles
  37   end
  38
  39   def self.default_panel_size
  40     30
  41   end
  42
  43   def self.max_panel_size
  44     200
  45   end
  46
  47   def self.offset cnt, prm = nil
  48     offset = prm.to_i
  49     offset = cnt - 1 if offset >= cnt
  50     offset = cnt - offset.abs if offset < 0
  51     offset = 0 if offset < 0
  52     offset
  53   end
  54
  55   def self.panel_count cnt, prm = self.default_panel_size
  56     count = prm.to_i
  57     count = self.max_panel_size if count > self.max_panel_size
  58     count = self.default_panel_size if count < 1
  59     count
  60   end
  61
  62   def self.default_page_size
  63     25
  64   end
  65
  66   def self.max_page_size
  67     100
  68   end
  69
  70   def self.page prm = nil
  71     page = prm.to_i
  72     page = 1 if page < 1
  73     page
  74   end
  75
  76   def self.page_size prm = self.default_page_size
  77     page_size = prm.to_i
  78     page_size = self.max_page_size if page_size > self.max_page_size
  79     page_size = self.default_page_size if page_size < 1
  80     page_size
  81   end
  82
  83   def self.play_list_where cid
  84     ['scroll_panels.scroll_id = ?', cid]
  85   end
  86
  87   def self.list_where
  88     'scrolls.visible > 0'
  89   end
  90
  91   def self.mylist_where au
  92     ['scroll_panels.author_id = ?', au.id]
  93   end
  94
  95   def self.himlist_where au
  96     ['scroll_panels.author_id = ? and scrolls.visible > 0', au.id]
  97   end
  98
  99   def self.play_list scroll, author, offset = 0, limit = ScrollPanel.default_panel_size
 100     ScrollPanel.where(self.play_list_where(scroll.id)).includes(ScrollPanel.list_opt).order('scroll_panels.t').offset(offset).limit(limit)
 101   end
 102
 103   def self.list page = 1, page_size = self.default_page_size
 104     ScrollPanel.where(self.list_where()).includes(ScrollPanel.list_opt).order('scroll_panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
 105   end
 106
 107   def self.mylist au, page = 1, page_size = Author.default_scroll_panel_page_size
 108     ScrollPanel.where(self.mylist_where(au)).includes(ScrollPanel.list_opt).order('scroll_panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
 109   end
 110
 111   def self.himlist au, page = 1, page_size = Author.default_scroll_panel_page_size
 112     ScrollPanel.where(self.himlist_where(au)).includes(ScrollPanel.list_opt).order('scroll_panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
 113   end
 114
 115   def self.list_paginate page = 1, page_size = self.default_page_size
 116     Kaminari.paginate_array(Array.new(ScrollPanel.where(self.list_where()).includes(ScrollPanel.list_opt).count, nil)).page(page).per(page_size)
 117   end
 118
 119   def self.mylist_paginate au, page = 1, page_size = Author.default_scroll_panel_page_size
 120     Kaminari.paginate_array(Array.new(ScrollPanel.where(self.mylist_where(au)).includes(ScrollPanel.list_opt).count, nil)).page(page).per(page_size)
 121   end
 122
 123   def self.himlist_paginate au, page = 1, page_size = Author.default_scroll_panel_page_size
 124     Kaminari.paginate_array(Array.new(ScrollPanel.where(self.himlist_where(au)).includes(ScrollPanel.list_opt).count, nil)).page(page).per(page_size)
 125   end
 126
 127   def self.list_opt
 128     {
 129       :author => {},
 130       :scroll => {
 131         :author => {}
 132       },
 133       :panel => {
 134         :author => {},
 135         :panel_pictures => {:picture => {:artist => {}, :license => {}}},
 136         :speech_balloons =>{:balloon => {}, :speech => {}}
 137       }
 138     }
 139   end
 140
 141   def self.list_json_opt
 142     {:include => {
 143       :author => {},
 144       :scroll => {
 145         :author => {}
 146       },
 147       :panel => {
 148         :author => {},
 149         :panel_pictures => {:picture => {:artist => {}, :license => {}}},
 150         :speech_balloons =>{:balloon => {}, :speech => {}}
 151       }
 152     }}
 153   end
 154
 155   def self.show spid, roles
 156     opt = {}
 157     opt.merge!(ScrollPanel.show_opt)
 158     res = ScrollPanel.find spid, opt
 159     raise ActiveRecord::Forbidden unless res.visible?(roles)
 160     res
 161   end
 162
 163   def self.edit spid, au
 164     opt = {}
 165     opt.merge!(ScrollPanel.show_opt)
 166     res = ScrollPanel.find spid, opt
 167     raise ActiveRecord::Forbidden unless res.own?(au)
 168     res
 169   end
 170
 171   def self.show_opt
 172     {:include => {
 173       :author => {},
 174       :scroll => {
 175         :author => {}
 176       },
 177       :panel => {
 178         :author => {},
 179         :panel_pictures => {:picture => {:artist => {}, :license => {}}},
 180         :speech_balloons =>{:balloon => {}, :speech => {}}
 181       }
 182     }}
 183   end
 184
 185   def elements
 186     self.panel.elements
 187   end
 188
 189   def scroll_panel_as_json au
 190     panel_include = if self.panel and self.panel.visible?(au)
 191       {:include => {:author => {}}, :methods => :elements}
 192     else
 193       {:include => {:author => {}}}
 194     end
 195     self.to_json({:include => {:scroll => {:include => {:author => {}}}, :author => {}, :panel => panel_include}})
 196   end
 197
 198   def self.list_as_json_text ary, au
 199     '[' + ary.map {|i| i.scroll_panel_as_json(au) }.join(',') + ']'
 200   end
 201
 202   def self.licensed_pictures scroll_panels
 203     r = {}
 204     scroll_panels.each do |scroll_panel|
 205       r.merge!(scroll_panel.panel.licensed_pictures) if scroll_panel.panel
 206     end
 207     r
 208   end
 209
 210   def self.new_t scroll_id
 211     r = ScrollPanel.max_t(scroll_id)
 212     r.blank? ? 0 : r.to_i + 1
 213   end
 214
 215   def self.max_t scroll_id
 216     ScrollPanel.maximum(:t, :conditions => ['scroll_id = ?', scroll_id])
 217   end
 218
 219   def self.find_t scroll_id, t
 220     ScrollPanel.find(:first, :conditions => ['scroll_id = ? and t = ?', scroll_id, t])
 221   end
 222
 223   def self.collect_t scroll_panel
 224     r = ScrollPanel.find(:all, :conditions => ['scroll_id = ?', scroll_panel.scroll_id], :order => 't')
 225     r.map {|sp| sp.t}
 226   end
 227
 228   def self.serial? ary
 229     i = 0
 230     ary.compact.sort.each do |t|
 231       break false unless t == i
 232       i += 1
 233     end
 234     ary.compact.size == i
 235   end
 236
 237   def self.validate_t scroll_panel
 238     ScrollPanel.serial?(ScrollPanel.collect_t(scroll_panel))
 239   end
 240
 241   def insert_shift
 242     ScrollPanel.update_all('t = t + 1', ['scroll_id = ? and t >= ?', self.scroll_id, self.t])
 243   end
 244
 245   def lesser_shift old_t
 246     self.t = 0 if self.t < 0
 247     ScrollPanel.update_all('t = t + 1', ['scroll_id = ? and (t >= ? and t < ?)', self.scroll_id, self.t, old_t])
 248   end
 249
 250   def higher_shift old_t
 251     nf = ScrollPanel.find_t(self.scroll_id, self.t)
 252     max_t = ScrollPanel.max_t(self.scroll_id).to_i
 253     self.t = max_t if self.t > max_t
 254     ScrollPanel.update_all('t = t - 1', ['scroll_id = ? and (t > ? and t <= ?)', self.scroll_id, old_t, self.t])
 255   end
 256
 257   def update_shift old_t
 258     if self.t > old_t
 259       higher_shift old_t
 260     else
 261       lesser_shift old_t
 262     end
 263   end
 264
 265   def rotate old_t = nil
 266     if self.new_record?
 267       if self.t.blank?
 268         self.t = ScrollPanel.new_t self.scroll_id
 269       else
 270         self.insert_shift
 271       end
 272     else
 273       if self.t.blank?
 274       else
 275         self.update_shift old_t
 276       end
 277     end
 278   end
 279
 280   def allow?
 281     return nil if self.scroll_id == nil or self.panel_id == nil
 282     self.scroll.own?(self.author) and self.panel.usable?(self.author)
 283   end
 284
 285   def store old_t = nil
 286     res = false
 287     ScrollPanel.transaction do
 288       case self.allow?
 289       when true
 290         self.rotate old_t
 291       when false
 292         raise ActiveRecord::Forbidden
 293       else
 294       end
 295       res = self.save
 296       raise ActiveRecord::Rollback unless res
 297       res = ScrollPanel.validate_t(self)
 298       unless res
 299         self.errors.add :t, 'unserialized'
 300         raise ActiveRecord::Rollback
 301       end
 302     end
 303     res
 304   end
 305
 306   def destroy_and_shorten
 307     res = false
 308     ScrollPanel.transaction do
 309       ScrollPanel.update_all('t = t - 1', ['scroll_id = ? and (t > ?)', self.scroll_id, self.t])
 310       raise ActiveRecord::Rollback unless self.destroy
 311       res = true
 312     end
 313     res
 314   end
 315
 316 end