class RailsNewsfeed::NewsfeedModel

Constants

SALT_KEY
SECRET_KEY

Attributes

id[R]
next_page_token[R]

Public Class Methods

delete(id, act_id = nil, related = false) click to toggle source

deletes by id

# File lib/rails_newsfeed/newsfeed_model.rb, line 34
def self.delete(id, act_id = nil, related = false)
  new(id: id).delete(act_id, related)
end
feeds(id, page_size = 10, next_page_token = nil) click to toggle source

gets feeds by id

# File lib/rails_newsfeed/newsfeed_model.rb, line 39
def self.feeds(id, page_size = 10, next_page_token = nil)
  new(id: id, next_page_token: next_page_token).feeds(page_size)
end
from_cass_act(id, res) click to toggle source
# File lib/rails_newsfeed/newsfeed_model.rb, line 43
def self.from_cass_act(id, res)
  { id: id, activity_id: res['id'].to_s, activity_content: res['content'],
    activity_object: res['object'], activity_time: res['time'].to_s }
end
insert(id, activity, related = true, hide_old = true) click to toggle source

inserts

# File lib/rails_newsfeed/newsfeed_model.rb, line 29
def self.insert(id, activity, related = true, hide_old = true)
  new(id: id).insert(activity, related, hide_old)
end
new(options = {}) click to toggle source

initializes

# File lib/rails_newsfeed/newsfeed_model.rb, line 49
def initialize(options = {})
  @id = options.key?(:id) ? options[:id] : nil
  @next_page_token = options.key?(:next_page_token) ? options[:next_page_token] : nil
end
schema() click to toggle source

gets schema DO NOT override this method unless you know what you are doing

# File lib/rails_newsfeed/newsfeed_model.rb, line 24
def self.schema
  { id: id_type, activity_id: :uuid, activity_content: :text, activity_object: :text, activity_time: :timestamp }
end
table_name() click to toggle source

gets table name

# File lib/rails_newsfeed/newsfeed_model.rb, line 18
def self.table_name
  name.demodulize.underscore
end
type_of_id(type) click to toggle source

sets type of id

# File lib/rails_newsfeed/newsfeed_model.rb, line 13
def self.type_of_id(type)
  self.id_type = type
end

Public Instance Methods

after_feeds() click to toggle source

overrides this method to implement your own

# File lib/rails_newsfeed/newsfeed_model.rb, line 109
def after_feeds
end
delete(act_id = nil, related = true) click to toggle source

deletes an activity or all activities from this feed

# File lib/rails_newsfeed/newsfeed_model.rb, line 77
def delete(act_id = nil, related = true)
  tbl = self.class.table_name
  schema = self.class.schema
  if act_id
    return Activity.delete(act_id, true) if related
    return Connection.delete(tbl, schema, id: @id, activity_id: act_id)
  end
  cqls = []
  Connection.select(tbl, schema, '*', id: @id).each do |r|
    if related
      Activity.delete(r['id'].to_s, true)
    else
      cqls.push(Connection.delete(tbl, schema, { id: @id, activity_id: r['id'].to_s }, true))
    end
  end
  Connection.batch_cqls(cqls.uniq)
  true
end
deregister(to, options = {}) click to toggle source

deregisters to another

# File lib/rails_newsfeed/newsfeed_model.rb, line 118
def deregister(to, options = {})
  Relation.delete(to, self, options)
end
feeds(page_size = 10) click to toggle source

gets feeds

# File lib/rails_newsfeed/newsfeed_model.rb, line 97
def feeds(page_size = 10)
  @feeds = []
  options = { page_size: page_size.to_i }
  options[:paging_state] = decoded_next_page_token if @next_page_token
  result = Connection.select(self.class.table_name, self.class.schema, '*', { id: @id }, options)
  result.each { |r| @feeds.push(Activity.create_from_cass(:feed, r)) }
  encoded_next_page_token(result)
  after_feeds
  @feeds
end
insert(activity, related = true, hide_old = true) click to toggle source

inserts an activity into table

# File lib/rails_newsfeed/newsfeed_model.rb, line 55
def insert(activity, related = true, hide_old = true)
  record = { id: @id, activity_id: activity.id, activity_content: activity.content,
             activity_object: activity.object, activity_time: activity.time }
  Connection.insert(self.class.table_name, self.class.schema, record)
  ins_arr = []
  cqls = []
  if related
    Relation.related_of(self).each do |ins|
      record[:id] = ins.id
      cqls.push(Connection.insert(ins.class.table_name, ins.class.schema, record, true))
      ins_arr.push(ins) if hide_old
    end
  end
  if hide_old
    ins_arr.push(self)
    cqls |= cql_hide_old_feeds_of(activity, ins_arr)
  end
  Connection.batch_cqls(cqls)
  true
end
register(to, options = {}) click to toggle source

registers to another

# File lib/rails_newsfeed/newsfeed_model.rb, line 113
def register(to, options = {})
  Relation.create(to, self, options)
end
register?(to) click to toggle source

checks related

# File lib/rails_newsfeed/newsfeed_model.rb, line 123
def register?(to)
  Relation.related?(to, self)
end

Protected Instance Methods

cql_hide_old_feeds_of(activity, ins_arr) click to toggle source

generates cqls to hide old feeds

# File lib/rails_newsfeed/newsfeed_model.rb, line 147
def cql_hide_old_feeds_of(activity, ins_arr)
  return [] unless activity.object
  cqls = []
  cond = { object: activity.object }
  Connection.select(activity.class.index_table_name, activity.class.schema, '*', cond).each do |r|
    id = r['id'].to_s
    next if id == activity.id
    ins_arr.each do |t|
      cqls.push(Connection.delete(t.class.table_name, t.class.schema, { id: t.id, activity_id: id }, true))
    end
  end
  cqls.uniq
end
decoded_next_page_token() click to toggle source

decodes next_page_token

# File lib/rails_newsfeed/newsfeed_model.rb, line 141
def decoded_next_page_token
  key = ActiveSupport::KeyGenerator.new(SECRET_KEY).generate_key(SALT_KEY)
  ActiveSupport::MessageEncryptor.new(key).decrypt_and_verify(@next_page_token)
end
encoded_next_page_token(result) click to toggle source

encodes next_page_token

# File lib/rails_newsfeed/newsfeed_model.rb, line 130
def encoded_next_page_token(result)
  if result.nil? || result.last_page?
    @next_page_token = nil
  else
    key = ActiveSupport::KeyGenerator.new(SECRET_KEY).generate_key(SALT_KEY)
    @next_page_token = ActiveSupport::MessageEncryptor.new(key).encrypt_and_sign(result.paging_state)
  end
  @next_page_token
end