app/models/story_sheet.rb

   1 class StorySheet < Pettanr::Item
   2   belongs_to :author
   3   belongs_to :story
   4   belongs_to :sheet
   5
   6   validates :story_id, :presence => true, :numericality => true, :existence => {:both => false}
   7   validates :sheet_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 self.singular
  12     'StorySheet'
  13   end
  14
  15   def self.plural
  16     'StorySheets'
  17   end
  18
  19   def self.owner_type
  20     :author
  21   end
  22
  23   def supply_default
  24     self.story_id = nil
  25     self.sheet_id = nil
  26     self.t = nil
  27   end
  28
  29   def overwrite au
  30     return false unless au
  31     self.author_id = au.id
  32   end
  33
  34   def own? roles
  35     roles = [roles] unless roles.respond_to?(:each)
  36     au = StorySheet.get_author_from_roles roles
  37     return false unless au
  38     self.author_id == au.id
  39   end
  40
  41   def visible? roles
  42     if MagicNumber['run_mode'] == 0
  43       return false unless guest_role_check(roles)
  44     else
  45       return false unless reader_role_check(roles)
  46     end
  47     return true if self.story.own?(roles)
  48     self.story.visible? roles
  49   end
  50
  51   def self.default_sheet_size
  52     30
  53   end
  54
  55   def self.max_sheet_size
  56     200
  57   end
  58
  59   def self.offset cnt, prm = nil
  60     offset = prm.to_i
  61     offset = cnt - 1 if offset >= cnt
  62     offset = cnt - offset.abs if offset < 0
  63     offset = 0 if offset < 0
  64     offset
  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.play_sheet_where sid
  89     ['story_sheets.story_id = ?', sid]
  90   end
  91
  92   def self.list_where
  93     'stories.visible > 0'
  94   end
  95
  96   def self.mylist_where au
  97     ['story_sheets.author_id = ?', au.id]
  98   end
  99
 100   def self.himlist_where au
 101     ['story_sheets.author_id = ? and stories.visible > 0', au.id]
 102   end
 103
 104   def self.play_sheet story, au, page = 1
 105     ss = StorySheet.where(self.play_sheet_where(story.id)).includes(StorySheet.list_opt).order('story_sheets.t').offset(page -1).limit(1).first
 106     if ss
 107       if ss.sheet
 108         Sheet.show(ss.sheet.id, au)
 109       else
 110         nil
 111       end
 112     else
 113       nil
 114     end
 115   end
 116
 117   def self.list page = 1, page_size = self.default_page_size
 118     StorySheet.where(self.list_where()).includes(StorySheet.list_opt).order('story_sheets.updated_at desc').offset((page -1) * page_size).limit(page_size)
 119   end
 120
 121   def self.mylist au, page = 1, page_size = Author.default_story_sheet_page_size
 122     StorySheet.where(self.mylist_where(au)).includes(StorySheet.list_opt).order('story_sheets.updated_at desc').offset((page -1) * page_size).limit(page_size)
 123   end
 124
 125   def self.himlist au, page = 1, page_size = Author.default_story_sheet_page_size
 126     StorySheet.where(self.himlist_where(au)).includes(StorySheet.list_opt).order('story_sheets.updated_at desc').offset((page -1) * page_size).limit(page_size)
 127   end
 128
 129   def self.list_paginate page = 1, page_size = self.default_page_size
 130     Kaminari.paginate_array(Array.new(StorySheet.where(self.list_where()).includes(StorySheet.list_opt).count, nil)).page(page).per(page_size)
 131   end
 132
 133   def self.mylist_paginate au, page = 1, page_size = Author.default_story_sheet_page_size
 134     Kaminari.paginate_array(Array.new(StorySheet.where(self.mylist_where(au)).includes(StorySheet.list_opt).count, nil)).page(page).per(page_size)
 135   end
 136
 137   def self.himlist_paginate au, page = 1, page_size = Author.default_story_sheet_page_size
 138     Kaminari.paginate_array(Array.new(StorySheet.where(self.himlist_where(au)).includes(StorySheet.list_opt).count, nil)).page(page).per(page_size)
 139   end
 140
 141   def self.play_paginate story, page
 142     Kaminari.paginate_array(Array.new(StorySheet.where(self.play_sheet_where(story.id)).includes(StorySheet.list_opt).count, nil)).page(page).per(1)
 143   end
 144
 145   def self.list_by_story_where story_id
 146     ['story_sheets.story_id = ?', story_id]
 147   end
 148
 149   def self.list_by_story story_id, roles, page = 1, page_size = self.default_page_size
 150     self.where(self.list_by_story_where(story_id)).includes(self.list_opt).order('story_sheets.updated_at desc').offset((page -1) * page_size).limit(page_size)
 151   end
 152
 153   def self.list_by_sheet_where sheet_id
 154     ['story_sheets.sheet_id = ?', sheet_id]
 155   end
 156
 157   def self.list_by_sheet sheet_id, roles, page = 1, page_size = self.default_page_size
 158     self.where(self.list_by_sheet_where(sheet_id)).includes(self.list_opt).order('story_sheets.updated_at desc').offset((page -1) * page_size).limit(page_size)
 159   end
 160
 161   def self.list_opt
 162     {
 163       :author => {},
 164       :story => {
 165       },
 166       :sheet => {
 167         :author => {},
 168       }
 169     }
 170   end
 171
 172   def self.list_json_opt
 173     {:include => {
 174       :author => {},
 175       :story => {} ,
 176       :sheet => {:include => {:author => {}}}
 177     }}
 178   end
 179
 180   def self.show spid, roles
 181     opt = {}
 182     opt.merge!(StorySheet.show_opt)
 183     res = StorySheet.find spid, opt
 184     raise ActiveRecord::Forbidden unless res.visible?(roles)
 185     res
 186   end
 187
 188   def self.edit spid, au
 189     opt = {}
 190     opt.merge!(StorySheet.show_opt)
 191     res = StorySheet.find spid, opt
 192     raise ActiveRecord::Forbidden unless res.own?(au)
 193     res
 194   end
 195
 196   def self.show_opt
 197     {:include => {
 198       :author => {},
 199       :story => {},
 200       :sheet => {
 201         :author => {}
 202       }
 203     }}
 204   end
 205
 206   def self.show_json_opt
 207     {:include => {
 208       :author => {},
 209       :story => {} ,
 210       :sheet => {:include => {:author => {}}}
 211     }}
 212   end
 213
 214   def elements
 215     self.panel.elements
 216   end
 217
 218   def story_sheet_as_json au
 219     panel_include = if self.panel and self.panel.visible?(au)
 220       {:include => {:author => {}}, :methods => :elements}
 221     else
 222       {:include => {:author => {}}}
 223     end
 224     self.to_json({:include => {:scroll => {:include => {:author => {}}}, :author => {}, :panel => panel_include}})
 225   end
 226
 227   def self.list_as_json_text ary, au
 228     '[' + ary.map {|i| i.story_sheet_as_json(au) }.join(',') + ']'
 229   end
 230
 231   def self.new_t story_id
 232     r = StorySheet.max_t(story_id)
 233     r.blank? ? 0 : r.to_i + 1
 234   end
 235
 236   def self.top_sheet story, author
 237     StorySheet.play_list(story, author).first
 238   end
 239
 240   def self.max_t story_id
 241     StorySheet.maximum(:t, :conditions => ['story_id = ?', story_id])
 242   end
 243
 244   def self.find_t story_id, t
 245     StorySheet.find(:first, :conditions => ['story_id = ? and t = ?', story_id, t])
 246   end
 247
 248   def self.collect_t story_sheet
 249     r = StorySheet.find(:all, :conditions => ['story_id = ?', story_sheet.story_id], :order => 't')
 250     r.map {|sp| sp.t}
 251   end
 252
 253   def self.serial? ary
 254     i = 0
 255     ary.compact.sort.each do |t|
 256       break false unless t == i
 257       i += 1
 258     end
 259     ary.compact.size == i
 260   end
 261
 262   def self.validate_t story_sheet
 263     StorySheet.serial?(StorySheet.collect_t(story_sheet))
 264   end
 265
 266   def insert_shift
 267     StorySheet.update_all('t = t + 1', ['story_id = ? and t >= ?', self.story_id, self.t])
 268   end
 269
 270   def lesser_shift old_t
 271     self.t = 0 if self.t < 0
 272     StorySheet.update_all('t = t + 1', ['story_id = ? and (t >= ? and t < ?)', self.story_id, self.t, old_t])
 273   end
 274
 275   def higher_shift old_t
 276     nf = StorySheet.find_t(self.story_id, self.t)
 277     max_t = StorySheet.max_t(self.story_id).to_i
 278     self.t = max_t if self.t > max_t
 279     StorySheet.update_all('t = t - 1', ['story_id = ? and (t > ? and t <= ?)', self.story_id, old_t, self.t])
 280   end
 281
 282   def update_shift old_t
 283     if self.t > old_t
 284       higher_shift old_t
 285     else
 286       lesser_shift old_t
 287     end
 288   end
 289
 290   def rotate old_t = nil
 291     if self.new_record?
 292       if self.t.blank?
 293         self.t = StorySheet.new_t self.story_id
 294       else
 295         self.insert_shift
 296       end
 297     else
 298       if self.t.blank?
 299       else
 300         self.update_shift old_t
 301       end
 302     end
 303   end
 304
 305   def allow?
 306     return nil if self.story_id == nil or self.sheet_id == nil
 307     self.story.own?(self.author) and self.sheet.usable?(self.author)
 308   end
 309
 310   def store old_t = nil
 311     res = false
 312     StorySheet.transaction do
 313       case self.allow?
 314       when true
 315         self.rotate old_t
 316       when false
 317         raise ActiveRecord::Forbidden
 318       else
 319       end
 320       res = self.save
 321       raise ActiveRecord::Rollback unless res
 322       res = StorySheet.validate_t(self)
 323       unless res
 324         self.errors.add :t, 'unserialized'
 325         raise ActiveRecord::Rollback
 326       end
 327     end
 328     res
 329   end
 330
 331   def destroy_and_shorten
 332     res = false
 333     StorySheet.transaction do
 334       StorySheet.update_all('t = t - 1', ['story_id = ? and (t > ?)', self.story_id, self.t])
 335       raise ActiveRecord::Rollback unless self.destroy
 336       res = true
 337     end
 338     res
 339   end
 340
 341 end