app/models/scroll.rb

   1 class Scroll < ActiveRecord::Base
   2   has_many :scroll_panels
   3   belongs_to :author
   4
   5   validates :title, :presence => true, :length => {:maximum => 100}
   6   validates :visible, :presence => true, :numericality => true, :inclusion => {:in => 0..1}
   7   validates :author_id, :presence => true, :numericality => true, :existence => {:both => false}
   8
   9   before_validation :valid_encode
  10
  11   def valid_encode
  12     ['title', 'description'].each do |a|
  13       next if attributes[a] == nil
  14       raise Pettanr::BadRequest unless attributes[a].valid_encoding?
  15     end
  16   end
  17
  18   def supply_default
  19     self.visible = 0 if self.visible.blank?
  20   end
  21
  22   def overwrite au
  23     return false unless au
  24     self.author_id = au.id
  25   end
  26
  27   def own? roles
  28     roles = [roles] unless roles.respond_to?(:each)
  29     au = Scroll.get_author_from_roles roles
  30     return false unless au
  31     self.author_id == au.id
  32   end
  33
  34   def visible? roles
  35     if MagicNumber['run_mode'] == 0
  36       return false unless guest_role_check(roles)
  37     else
  38       return false unless reader_role_check(roles)
  39     end
  40     return true if self.own?(roles)
  41     self.visible > 0
  42   end
  43
  44   def scroll_panels_count
  45     ScrollPanel.where(['scroll_panels.scroll_id = ?', self.id]).count
  46   end
  47
  48   def self.default_page_size
  49     25
  50   end
  51
  52   def self.max_page_size
  53     100
  54   end
  55
  56   def self.default_panel_size
  57     30
  58   end
  59
  60   def self.max_panel_size
  61     200
  62   end
  63
  64   def self.page prm = nil
  65     page = prm.to_i
  66     page = 1 if page < 1
  67     page
  68   end
  69
  70   def self.page_size prm = self.default_page_size
  71     page_size = prm.to_i
  72     page_size = self.max_page_size if page_size > self.max_page_size
  73     page_size = self.default_page_size if page_size < 1
  74     page_size
  75   end
  76
  77   def self.list_where
  78     'scrolls.visible > 0'
  79   end
  80
  81   def self.mylist_where au
  82     ['scrolls.author_id = ?', au.id]
  83   end
  84
  85   def self.himlist_where au
  86     ['scrolls.author_id = ? and scrolls.visible > 0', au.id]
  87   end
  88
  89   def self.list page = 1, page_size = self.default_page_size
  90     Scroll.where(self.list_where()).includes(Scroll.list_opt).order('scrolls.updated_at desc').offset((page -1) * page_size).limit(page_size)
  91   end
  92
  93   def self.mylist au, page = 1, page_size = Author.default_scroll_page_size
  94     Scroll.where(self.mylist_where(au)).includes(Scroll.list_opt).order('scrolls.updated_at desc').offset((page -1) * page_size).limit(page_size)
  95   end
  96
  97   def self.himlist au, page = 1, page_size = Author.default_scroll_page_size
  98     Scroll.where(self.himlist_where(au)).includes(Scroll.list_opt).order('scrolls.updated_at desc').offset((page -1) * page_size).limit(page_size)
  99   end
 100
 101   def self.list_paginate page = 1, page_size = self.default_page_size
 102     Kaminari.paginate_array(Array.new(Scroll.where(self.list_where()).count, nil)).page(page).per(page_size)
 103   end
 104
 105   def self.mylist_paginate au, page = 1, page_size = Author.default_scroll_page_size
 106     Kaminari.paginate_array(Array.new(Scroll.where(self.mylist_where(au)).count, nil)).page(page).per(page_size)
 107   end
 108
 109   def self.himlist_paginate au, page = 1, page_size = Author.default_scroll_page_size
 110     Kaminari.paginate_array(Array.new(Scroll.where(self.himlist_where(au)).count, nil)).page(page).per(page_size)
 111   end
 112
 113   def self.list_by_panel panel_id, roles, page = 1, page_size = self.default_page_size
 114     self.where(ScrollPanel.list_by_panel_where(panel_id)).includes(
 115       {:scroll_panels => {}}
 116     ).order('scroll_panels.updated_at desc').offset((page -1) * page_size).limit(page_size)
 117   end
 118
 119   def self.list_by_author_where author_id
 120     ['scrolls.author_id = ?', author_id]
 121   end
 122
 123   def self.list_by_author author_id, roles, page = 1, page_size = self.default_page_size
 124     self.where(self.list_by_author_where(author_id)).includes(self.list_opt).order('scrolls.updated_at desc').offset((page -1) * page_size).limit(page_size)
 125   end
 126
 127   def self.list_opt
 128     {:scroll_panels => {:panel => {}}, :author => {} }
 129   end
 130
 131   def self.list_json_opt
 132     {:include => {:scroll_panels => {:include => {:panel => {}}}, :author => {}}}
 133   end
 134
 135   def self.show sid, roles
 136     opt = {}
 137     opt.merge!(Scroll.show_opt)
 138     res = Scroll.find(sid, opt)
 139     raise ActiveRecord::Forbidden unless res.visible?(roles)
 140     res
 141   end
 142
 143   def self.edit sid, au
 144     opt = {}
 145     opt.merge!(Scroll.show_opt)
 146     res = Scroll.find(sid, opt)
 147     raise ActiveRecord::Forbidden unless res.own?(au)
 148     res
 149   end
 150
 151   def self.show_opt
 152     {:include => {:scroll_panels => {:panel => {}}, :author => {}}}
 153   end
 154
 155   def self.show_json_opt
 156     {:include => {:scroll_panels => {:include => {:panel => {}}}, :author => {}}}
 157   end
 158
 159   def self.visible_count
 160     Scroll.count 'visible > 0'
 161   end
 162
 163   def destroy_with_scroll_panel
 164     res = false
 165     Scroll.transaction do
 166       self.scroll_panels.each do |scroll_panel|
 167         raise ActiveRecord::Rollback unless scroll_panel.destroy
 168       end
 169       raise ActiveRecord::Rollback unless self.destroy
 170       res = true
 171     end
 172     res
 173   end
 174
 175   def scenario
 176     panels.map {|panel|
 177       panel.scenario
 178     }.join
 179   end
 180
 181   def plain_scenario
 182     panels.map {|panel|
 183       panel.plain_scenario
 184     }.join
 185   end
 186
 187 end