libertree-model 0.9.11

data/lib/libertree/model/comment.rb

@@ -0,0 +1,164 @@
+require_relative '../embedder'
+
+module Libertree
+  module Model
+    class Comment < Sequel::Model(:comments)
+      include IsRemoteOrLocal
+      extend HasSearchableText
+      include HasDisplayText
+
+      def after_create
+        super
+
+        if self.local? && self.post.distribute?
+          Libertree::Model::Job.create_for_forests(
+            {
+              task: 'request:COMMENT',
+              params: { 'comment_id' => self.id, }
+            },
+            *self.forests
+          )
+        end
+        Libertree::Embedder.autoembed(self.text)
+      end
+
+      # TODO: DB: association
+      def member
+        @member = Member[self.member_id]
+      end
+
+      # TODO: DB: association
+      def post
+        @post = Post[self.post_id]
+      end
+
+      def before_destroy
+        if self.post
+          remaining_comments = self.post.comments - [self]
+          self.post.time_commented = remaining_comments.map(&:time_created).max
+        end
+
+        if self.local? && self.post.distribute?
+          Libertree::Model::Job.create_for_forests(
+            {
+              task: 'request:COMMENT-DELETE',
+              params: { 'comment_id' => self.id, }
+            },
+            *self.forests
+          )
+        end
+        super
+      end
+
+      # TODO: the correct method to call is "destroy"
+      def delete
+        self.before_destroy
+        super
+      end
+
+      # NOTE: deletion is NOT distributed when force=true
+      def delete_cascade(force=false)
+        self.before_destroy  unless force
+        DB.dbh[ "SELECT delete_cascade_comment(?)", self.id ].get
+      end
+
+      def self.create(*args)
+        comment = super
+        account = comment.member.account
+        post = comment.post
+
+        post.time_commented = comment.time_created
+        post.mark_as_unread_by_all  except: [account]
+        if account
+          post.mark_as_read_by account
+          account.subscribe_to comment.post
+        end
+        post.notify_about_comment comment
+        post.save
+
+        comment
+      end
+
+      def likes
+        @likes ||= CommentLike.where(comment_id: self.id).reverse_order(:id)
+      end
+
+      def notify_about_like(like)
+        notification_attributes = {
+          'type'         => 'comment-like',
+          'comment_like_id' => like.id,
+        }
+        local_comment_author = like.comment.member.account
+        like_author = like.member.account
+
+        if(
+          local_comment_author &&
+          (!like_author || local_comment_author.id != like_author.id) &&
+          ! local_comment_author.ignoring?(like.member)
+        )
+          local_comment_author.notify_about notification_attributes
+        end
+      end
+
+      def like_by(member)
+        # take advantage of cached self.likes
+        if self.likes.is_a? Array
+          self.likes.find {|like| like.member.id == member.id}
+        else
+          CommentLike[ member_id: member.id, comment_id: self.id ]
+        end
+      end
+
+      # overriding method from IsRemoteOrLocal
+      def forests
+        if self.post.remote?
+          self.post.server.forests
+        else
+          Libertree::Model::Forest.all_local_is_member
+        end
+      end
+
+      def to_hash
+        {
+          'id'           => self.id,
+          'time_created' => self.time_created,
+          'time_updated' => self.time_updated,
+          'text'         => self.text,
+          'post_id'      => self.post_id,
+        }
+      end
+
+      # TODO: When more visibilities come, restrict this result set by visibility
+      def self.comments_since_id(comment_id)
+        self.where{ id > comment_id }.order(:id)
+      end
+
+      # @param [Hash] opt options for restricting the comment set returned
+      # @option opts [Fixnum] :from_id Only return comments with id greater than or equal to this id
+      # @option opts [Fixnum] :to_id Only return comments with id less than this id
+      # @option opts [Account] :viewing_account An account to use to hide comments by ignored members
+      def self.on_post(post, opt = {})
+        res = Comment.where(post_id: post.id)
+        if opt[:viewing_account]
+          # Array() because sometimes opt[:viewing_account] is a strange nil-like object for some reason.
+          # Ramaze weirdness?
+          res = res.exclude(member_id: Array(opt[:viewing_account].ignored_members).map(&:id))
+        end
+
+        # reverse ordering is required in order to get the *last* n
+        # comments, rather than the first few when using :limit
+        res = res.reverse_order(:id)
+        res = res.where{ id >= opt[:from_id].to_i }  if opt[:from_id]
+        res = res.where{ id < opt[:to_id].to_i }     if opt[:to_id]
+        res = res.limit(opt[:limit].to_i)            if opt[:limit]
+        res.all.reverse
+      end
+
+      def guid
+        server = self.member.server
+        origin = server ? server.domain : Server.own_domain
+        "xmpp:#{origin}?;node=/comments;item=#{self.public_id}"
+      end
+    end
+  end
+end

data/lib/libertree/model/contact-list.rb

@@ -0,0 +1,81 @@
+module Libertree
+  module Model
+    class ContactList < Sequel::Model(:contact_lists)
+      def account
+        @account ||= Account[self.account_id]
+      end
+
+      def members
+        return @members   if @members
+
+        @members = Member.s(
+          %{
+            SELECT
+              m.*
+            FROM
+                contact_lists_members clm
+              , members m
+            WHERE
+              clm.contact_list_id = ?
+              AND m.id = clm.member_id
+          },
+          self.id
+        )
+      end
+
+      def member_ids
+        Libertree::DB.dbh[:contact_lists_members].
+          select(:member_id).
+          where(:contact_list_id => self.id).
+          all.
+          flat_map(&:values)
+      end
+
+      def members=(arg)
+        DB.dbh.transaction do
+          DB.dbh[ "DELETE FROM contact_lists_members WHERE contact_list_id = ?", self.id ].get
+          Array(arg).each do |member_id_s|
+            DB.dbh[ "INSERT INTO contact_lists_members ( contact_list_id, member_id ) VALUES ( ?, ? )", self.id, member_id_s.to_i ].get
+          end
+        end
+      end
+
+      def delete_cascade
+        DB.dbh[ "SELECT delete_cascade_contact_list(?)", self.id ].get
+      end
+
+      def <<(member)
+        # refuse to add anything that's not a Member
+        return  unless member.is_a? Member
+
+        Libertree::DB.dbh.transaction do
+          unless self.member_ids.include?(member.id)
+            Libertree::DB.dbh[:contact_lists_members].
+              insert(contact_list_id: self.id, member_id: member.id)
+          end
+        end
+      end
+
+      # refresh any river containing a reference to this contact list
+      def refresh_rivers
+        rivers = account.rivers.select do |r|
+          vals = r.parsed_query['contact-list'].values.flatten(1)
+          ! vals.empty? && vals.map(&:first).include?(self.id)
+        end
+
+        # refresh rivers in background jobs
+        rivers.each do |river|
+          if ! river.appended_to_all
+            Libertree::Model::Job.create(
+              task: 'river:refresh',
+              params: {
+                'river_id' => river.id,
+              }.to_json
+            )
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/libertree/model/embed-cache.rb

@@ -0,0 +1,6 @@
+module Libertree
+  module Model
+    class EmbedCache < Sequel::Model(:embed_cache)
+    end
+  end
+end

data/lib/libertree/model/file.rb

@@ -0,0 +1,6 @@
+module Libertree
+  module Model
+    class File < Sequel::Model(:files)
+    end
+  end
+end

data/lib/libertree/model/forest.rb

@@ -0,0 +1,82 @@
+module Libertree
+  module Model
+    class Forest < Sequel::Model(:forests)
+      def trees
+        Server.s(
+          %{
+            SELECT
+              s.*
+            FROM
+                forests_servers fs
+              , servers s
+            WHERE
+              fs.forest_id = ?
+              AND s.id = fs.server_id
+          },
+          self.id
+        )
+      end
+      alias :servers :trees
+
+      def add(server)
+        DB.dbh[
+          %{
+            INSERT INTO forests_servers (
+              forest_id, server_id
+            ) SELECT
+              ?, ?
+            WHERE NOT EXISTS(
+              SELECT 1
+              FROM forests_servers fs2
+              WHERE
+                fs2.forest_id = ?
+                AND fs2.server_id = ?
+            )
+          },
+          self.id,
+          server.id,
+          self.id,
+          server.id
+        ].get
+      end
+
+      def remove(server)
+        DB.dbh[ "DELETE FROM forests_servers WHERE forest_id = ? AND server_id = ?", self.id, server.id ].get
+      end
+
+      def local?
+        ! origin_server_id
+      end
+      def self.all_local_is_member
+        where  local_is_member: true
+      end
+
+      def origin
+        Server[origin_server_id]
+      end
+
+      def local_is_member?
+        local_is_member
+      end
+
+      # @param [Array(String)] domains
+      # @return [Array(Model::Server)] any new Server records that were created
+      def set_trees_by_domain(domains)
+        DB.dbh[ "DELETE FROM forests_servers WHERE forest_id = ?", self.id ].get
+        new_trees = []
+
+        domains.each do |domain|
+          tree = Model::Server[domain: domain]
+          if tree.nil?
+            tree = Model::Server.create(domain: domain)
+            new_trees << tree
+          end
+
+          self.add tree
+        end
+
+        new_trees
+      end
+    end
+  end
+end

data/lib/libertree/model/group-member.rb

@@ -0,0 +1,13 @@
+module Libertree
+  module Model
+    class GroupMember < Sequel::Model(:groups_members)
+      def group
+        Libertree::Model::Group[self.group_id]
+      end
+
+      def member
+        Libertree::Model::Member[self.member_id]
+      end
+    end
+  end
+end

data/lib/libertree/model/group.rb

@@ -0,0 +1,47 @@
+module Libertree
+  module Model
+    class Group < Sequel::Model(:groups)
+      def after_create
+        super
+        # Add creator of the group to the group
+        Libertree::Model::GroupMember.create(group_id: self.id, member_id: self.admin_member_id)
+      end
+
+      def add_member(member)
+        Libertree::Model::GroupMember.create(group_id: self.id, member_id: member.id)
+      end
+
+      def remove_member(member)
+        self.group_member(member).delete
+      end
+
+      def member?(member)
+        self.group_member(member).any?
+      end
+
+      def members
+        Libertree::Model::GroupMember.where(group_id: self.id).map { |gm| gm.member }
+      end
+
+      def posts( opts = {} )
+        time = Time.at(
+          opts.fetch(:time, Time.now.to_f)
+        ).strftime("%Y-%m-%d %H:%M:%S.%6N%z")
+
+        Post.s(
+          "SELECT * FROM posts_in_group(?,?,?,?,?,?)",
+          self.id,
+          opts.fetch(:viewer_account_id),
+          time,
+          opts[:newer],
+          opts[:order_by] == :comment,
+          opts.fetch(:limit, 30)
+        )
+      end
+
+      def group_member(member)
+        Libertree::Model::GroupMember.where(group_id: self.id, member_id: member.id)
+      end
+    end
+  end
+end

data/lib/libertree/model/has-display-text.rb

@@ -0,0 +1,34 @@
+require 'libertree/render'
+
+module Libertree
+  module Model
+    # Provides a "glimpse" instance method to objects that have a "text" field.
+    module HasDisplayText
+      def glimpse( length = 60 )
+        set_without_blockquotes = text_to_nodeset
+        set_without_blockquotes.xpath('.//blockquote').each(&:remove)
+        plain_text = set_without_blockquotes.inner_text.strip
+
+        if plain_text.empty?
+          plain_text = text_to_nodeset.inner_text.strip
+        end
+
+        plain_text = plain_text.gsub("\n", ' ')
+        snippet = plain_text[0...length]
+        if plain_text.length > length
+          snippet += '...'
+        end
+
+        snippet
+      end
+
+      def text_as_html
+        Render.to_html_nodeset(self.text)
+      end
+
+      def text_to_nodeset
+        Render.to_html_nodeset(self.text, [:no_images, :filter_html])
+      end
+    end
+  end
+end

data/lib/libertree/model/has-searchable-text.rb

@@ -0,0 +1,19 @@
+module Libertree
+  module Model
+    # Provides a "search" class method to a class that has a "text" field
+    # and a time_created field.
+    module HasSearchableText
+      def search(q, limit = 42, exact=true)
+        if exact
+          dict = 'simple'
+        else
+          dict = 'english'
+        end
+        self.where("(to_tsvector('simple', text) || to_tsvector('english', text)) @@ plainto_tsquery('#{dict}', ?)", q).
+          reverse_order(:time_created).
+          limit(limit.to_i).
+          all
+      end
+    end
+  end
+end

data/lib/libertree/model/ignored-member.rb

@@ -0,0 +1,13 @@
+module Libertree
+  module Model
+    class IgnoredMember < Sequel::Model(:ignored_members)
+      def account
+        Libertree::Model::Account[self.account_id]
+      end
+
+      def member
+        Libertree::Model::Member[self.member_id]
+      end
+    end
+  end
+end

data/lib/libertree/model/invitation.rb

@@ -0,0 +1,6 @@
+module Libertree
+  module Model
+    class Invitation < Sequel::Model(:invitations)
+    end
+  end
+end

data/lib/libertree/model/is-remote-or-local.rb

@@ -0,0 +1,30 @@
+module Libertree
+  module Model
+    module IsRemoteOrLocal
+      def public_id
+        self.remote_id || self.id
+      end
+
+      def remote?
+        !! remote_id
+      end
+
+      def local?
+        ! remote_id
+      end
+
+      def server
+        @server ||= self.member.server
+      end
+
+      def forests
+        if self.remote?
+          self.server.forests
+        else
+          Libertree::Model::Forest.all_local_is_member
+        end
+      end
+    end
+  end
+end
+

data/lib/libertree/model/job.rb

@@ -0,0 +1,93 @@
+require 'json'
+require 'set'
+
+module Libertree
+  module Model
+    class Job < Sequel::Model(:jobs)
+      MAX_TRIES = 48
+      RETRY_FACTOR = 0.2
+
+      def params
+        if val = super
+          JSON.parse val
+        end
+      end
+
+      def retry!
+        self.pid = self.time_started = self.time_finished = nil
+        self.time_to_start = Time.now
+        self.tries = 0
+        self.save
+      end
+
+      # First parameter can be a Forest Array.
+      # Otherwise, assumed to create for all member forests.
+      def self.create_for_forests(create_args, *forests)
+        if forests.empty?
+          forests = Forest.all_local_is_member
+        end
+
+        trees = Set.new
+        forests.each do |f|
+          if f.local_is_member?
+            trees += f.trees
+          end
+        end
+        trees.each do |tree|
+          params = ( create_args[:params] || create_args['params'] || Hash.new )
+          params['server_id'] = tree.id
+          Libertree::Model::Job.create(
+            task: create_args[:task],
+            params: params.to_json
+          )
+        end
+      end
+
+      # @return [Job] nil if no job was reserved
+      def self.reserve(tasks)
+        job = self.where("task IN ? AND pid IS NULL AND tries < #{MAX_TRIES} AND time_to_start <= NOW()", tasks).order(:time_to_start).limit(1).first
+        return nil  if job.nil?
+
+        self.where({ id: job.id, pid: nil }).
+          update({ pid: Process.pid, time_started: Time.now })
+
+        job = Job[job.id]
+        if job.pid == Process.pid
+          job
+        end
+      end
+
+      def unreserve
+        new_tries = self.tries+1
+        self.update(
+          time_started: nil,
+          pid: nil,
+          tries: new_tries,
+          time_to_start: Time.now + 60 * Math::E**(new_tries * RETRY_FACTOR)
+        )
+      end
+
+      def self.pending_where(*args)
+        query = args[0]
+        params = args[1..-1]
+
+        self.where(
+          query + %{
+            AND time_finished IS NULL
+            AND tries < ?
+          },
+          *params,
+          MAX_TRIES
+        )
+      end
+
+      def self.unfinished(task=nil)
+        if task
+          self.where("task = ? AND time_finished IS NULL", task).all
+        else
+          self.where("time_finished IS NULL").all
+        end
+      end
+    end
+  end
+end