Class: Libertree::Model::Pool

Inherits:
Object
  • Object
show all
Includes:
IsRemoteOrLocal
Defined in:
lib/libertree/model/pool.rb

Instance Method Summary collapse

Methods included from IsRemoteOrLocal

#forests, #local?, #public_id, #remote?, #server

Instance Method Details

#<<(post) ⇒ Object 



131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
 
# File 'lib/libertree/model/pool.rb', line 131

def <<(post)
  pool_post = PoolPost[ pool_id: self.id, post_id: post.id ]
  if pool_post.nil?
    pool_post_created = true
    pool_post = PoolPost.create(
      'pool_id' => self.id,
      'post_id' => post.id
    )
  end

  self.dirty
  if self.sprung? && pool_post_created
    self.notify_about_springing pool_post
    if self.local?
      create_pool_post_job(post)
    end
  end
end

#after_create ⇒ Object 



29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/libertree/model/pool.rb', line 29

def after_create
  super
  if self.local? && self.sprung?
    Libertree::Model::Job.create_for_forests(
      {
        task: 'request:POOL',
        params: { 'pool_id' => self.id, }
      },
      *self.forests
    )
  end
end

#after_update ⇒ Object 



42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/libertree/model/pool.rb', line 42

def after_update
  super
  if self.local?
    if ! self.sprung?
      self.create_pool_delete_job
    else
      if self.previous_changes.include?(:sprung)
        Libertree::Model::Job.create_for_forests(
          {
            task: 'request:POOL',
            params: { 'pool_id' => self.id, }
          },
          *self.forests
        )
        self.posts.last(16).each do |post|
          self.create_pool_post_job(post)
        end
      end
    end
  end
end

#before_destroy ⇒ Object 



64
65
66
67
68
69
 
# File 'lib/libertree/model/pool.rb', line 64

def before_destroy
  if self.local? && self.sprung?
    self.create_pool_delete_job
  end
  super
end

#create_pool_delete_job ⇒ Object 



19
20
21
22
23
24
25
26
27
 
# File 'lib/libertree/model/pool.rb', line 19

def create_pool_delete_job
  Libertree::Model::Job.create_for_forests(
    {
      task: 'request:POOL-DELETE',
      params: { 'pool_id' => self.id, }
    },
    *self.forests
  )
end

#create_pool_post_job(post) ⇒ Object 



6
7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/libertree/model/pool.rb', line 6

def create_pool_post_job(post)
  Libertree::Model::Job.create_for_forests(
    {
      task: 'request:POOL-POST',
      params: {
        'pool_id' => self.id,
        'post_id' => post.id,
      }
    },
    *self.forests
  )
end

#delete_cascade ⇒ Object

NOTE: deletion is NOT distributed



102
103
104
 
# File 'lib/libertree/model/pool.rb', line 102

def delete_cascade
  DB.dbh[ "SELECT delete_cascade_pool(?)", self.id ].get
end

#dirty ⇒ Object 



106
107
108
109
 
# File 'lib/libertree/model/pool.rb', line 106

def dirty
  @posts = nil
  self
end

#includes?(post) ⇒ Boolean

Returns:

  • (Boolean) 


97
98
99
 
# File 'lib/libertree/model/pool.rb', line 97

def includes?(post)
  DB.dbh[ "SELECT EXISTS( SELECT 1 FROM pools_posts WHERE post_id = ? AND pool_id = ? LIMIT 1 )", post.id, self.id ].single_value
end

#member ⇒ Object 



71
72
73
 
# File 'lib/libertree/model/pool.rb', line 71

def member
  @member ||= Member[self.member_id]
end

#notify_about_springing(pool_post) ⇒ Object 



111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/libertree/model/pool.rb', line 111

def notify_about_springing(pool_post)
  pool = pool_post.pool
  return  if ! pool.sprung

  post = pool_post.post
  local_post_author = post.member.
  pool_owner = pool.member.

  if(
    local_post_author &&
    local_post_author != pool_owner &&
    ! local_post_author.ignoring?(pool.member)
  )
    local_post_author.notify_about( {
      'type'         => 'springing',
      'pool_post_id' => pool_post.id,
    } )
  end
end

#posts(opts = {}) ⇒ Object

TODO: DRY up with member.posts?



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
# File 'lib/libertree/model/pool.rb', line 76

def posts( opts = {} )
  limit = opts.fetch(:limit, 30)
  time = Time.at( opts.fetch(:time, Time.now.to_f) ).strftime("%Y-%m-%d %H:%M:%S.%6N%z")
  time_clause = if opts[:newer]
                  proc { time_created > time }
                else
                  proc { time_created < time }
                end

  res = Post.qualify.
    join(:pools_posts, :post_id=>:id).
    where(&time_clause).
    where(:pool_id => self.id).
    reverse_order(:posts__id).
    limit(limit)

  # optionally restrict to Internet visible posts
  res = res.where(visibility: 'internet')  if opts[:public]
  res
end

#remove_post(post) ⇒ Object 



150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/libertree/model/pool.rb', line 150

def remove_post(post)
  DB.dbh[  "DELETE FROM pools_posts WHERE pool_id = ? AND post_id = ?", self.id, post.id ].get
  self.dirty
  if self.local? && self.sprung?
    Libertree::Model::Job.create_for_forests(
      {
        task: 'request:POOL-POST-DELETE',
        params: {
          'pool_id' => self.id,
          'post_id' => post.id,
        }
      },
      *self.forests
    )
  end
end

#sprung? ⇒ Boolean

Returns:

  • (Boolean) 


167
168
169
 
# File 'lib/libertree/model/pool.rb', line 167

def sprung?
  self.sprung
end