libertree-model 0.9.11

data/lib/libertree/model/member.rb

@@ -0,0 +1,222 @@
+module Libertree
+  module Model
+    class Member < Sequel::Model(:members)
+
+      def after_create
+        super
+        self.distribute
+      end
+
+      def after_update
+        super
+        self.distribute
+      end
+
+      def before_destroy
+        # TODO: expand later for more granularity:
+        #       - only abandon (not delete) posts and comments
+        #       - only empty posts if they contain a discussion
+        #       - only empty and anonymise comments
+        #       - etc.
+        if self.local?
+          Libertree::Model::Job.create_for_forests(
+            {
+              task: 'request:MEMBER-DELETE',
+              params: { 'username' => self.account.username, }
+            }
+          )
+        end
+        super
+      end
+
+      def distribute
+        return  if ! self.local?
+        Libertree::Model::Job.create_for_forests(
+          { task: 'request:MEMBER',
+            params: { 'username' => self.account.username }
+          }
+        )
+      end
+
+      def local?
+        ! self.account.nil?
+      end
+
+      def account
+        @account ||= Account[self.account_id]
+      end
+
+      # TODO: DB: association
+      #many_to_one :server
+      def server
+        @server ||= Server[self.server_id]
+      end
+      alias :tree :server
+
+      def name_display
+        @name_display ||= ( profile && profile.name_display || self.username )
+      end
+
+      def handle
+        if self.username && self.server
+          self.username + "@#{self.server.name_display}"
+        elsif account
+          account.username + "@#{Server.own_domain}"
+        end
+      end
+
+      def self.with_handle(h)
+        if h =~ /^(.+?)@(.+?)$/
+          username = $1
+          host = $2
+          if host == Server.own_domain
+            local = true
+          end
+        else
+          username = h
+          local = true
+        end
+
+        if local
+          self.qualify.
+            join(:accounts, :id=>:account_id).
+            where(:accounts__username => username).
+            limit(1).
+            first
+        else
+          # TODO: servers.name_given is no longer used.  Remove it after
+          # migrating user rivers/contact lists etc.
+          self.qualify.
+            join(:servers, :id=>:server_id).
+            where(:members__username => username).
+            where(Sequel.or(:servers__domain => host, :servers__name_given => host)).
+            limit(1).
+            first
+        end
+      end
+
+      # TODO: this is a temporary helper because with_handle no longer includes display name matches.
+      # This will eventually be removed when river :from queries no longer accept display names.
+      def self.with_display_name(name)
+        self.qualify.
+          join(:profiles, :member_id=>:id).
+          where(:profiles__name_display => name).
+          limit(1).
+          first
+      end
+
+      def username
+        if val = super
+          val
+        elsif a = self.account
+          a.username
+        end
+      end
+
+      # TODO: DB: association
+      def profile
+        @profile ||= Profile[ member_id: self.id ]
+      end
+
+      def self.create(*args)
+        member = super
+        Profile.create( member_id: member.id )
+        member
+      end
+
+      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.where(member_id: self.id).
+          where(&time_clause).
+          reverse_order(:time_created).
+          limit(limit)
+
+        # optionally restrict to Internet visible posts
+        res = res.where(visibility: 'internet')  if opts[:public]
+        res
+      end
+
+      def comments(n = 10)
+        Comment.where(member_id: self.id).reverse_order(:id).limit(n)
+      end
+
+      def pools
+        @pools ||= Pool.where( member_id: self.id ).all
+      end
+      def springs
+        @springs ||= Pool.where( member_id: self.id, sprung: true ).all
+      end
+
+      def online?
+        self.account && self.account.online?
+      end
+
+      def delete_cascade
+        DB.dbh[ "SELECT delete_cascade_member(?)", self.id ].get
+      end
+
+      def dirty
+        @account = nil
+        @name_display = nil
+        @profile = nil
+        @pools = nil
+        @springs = nil
+      end
+
+      def self.search(name:, include_old: false)
+        if include_old
+          newness_clause = "TRUE"
+        else
+          newness_clause = %{
+            EXISTS (
+              SELECT 1
+              FROM posts po
+              WHERE
+                po.member_id = m.id
+                AND po.time_created > NOW() - '30 days'::INTERVAL
+            ) OR EXISTS (
+              SELECT 1
+              FROM comments c
+              WHERE
+                c.member_id = m.id
+                AND c.time_created > NOW() - '30 days'::INTERVAL
+            )
+          }
+        end
+
+        self.s(
+          %{
+            SELECT
+                m.*
+            FROM
+                members m
+                LEFT OUTER JOIN accounts a ON (a.id = m.account_id)
+                LEFT OUTER JOIN profiles p ON (m.id = p.member_id)
+            WHERE
+              (
+                m.username ILIKE '%' || ? || '%'
+                OR a.username ILIKE '%' || ? || '%'
+                OR p.name_display ILIKE '%' || ? || '%'
+              ) AND (
+                #{newness_clause}
+              )
+          },
+          name,
+          name,
+          name
+        )
+      end
+
+      def groups
+        Libertree::Model::GroupMember.where(member_id: self.id).map { |gm| gm.group }
+      end
+    end
+  end
+end

data/lib/libertree/model/message.rb

@@ -0,0 +1,154 @@
+require 'set'
+
+module Libertree
+  module Model
+    class Message < Sequel::Model(:messages)
+      include HasDisplayText
+
+      def sender
+        @sender ||= Member[self.sender_member_id]
+      end
+      alias :member :sender
+
+      def distribute
+        trees = self.recipients.reduce(Set.new) { |_trees, recipient|
+          if recipient.tree
+            _trees << recipient.tree
+          end
+          _trees
+        }
+        recipient_ids = self.recipients.map(&:id)
+
+        trees.each do |tree|
+          Libertree::Model::Job.create(
+            {
+              task: 'request:MESSAGE',
+              params: {
+                'message_id'           => self.id,
+                'server_id'            => tree.id,
+                'recipient_member_ids' => recipient_ids,
+              }.to_json,
+            }
+          )
+        end
+      end
+
+      # forward direct message to the given email address of the provided account
+      def forward_via_email(account)
+        return  unless account
+        return  unless self.visible_to?(account)
+
+        Libertree::Model::Job.create(
+          task: 'forward-via-email',
+          params: {
+            'username' => account.username,
+            'message_id' => self.id
+          }.to_json
+        )
+      end
+
+      def recipients
+        return @recipients  if @recipients
+        @recipients = Member.s(
+          %{
+            SELECT
+              m.*
+            FROM
+                members m
+              , message_recipients mr
+            WHERE
+              mr.message_id = ?
+              AND m.id = mr.member_id
+          },
+          self.id
+        )
+      end
+
+      # the subset of participants who have not deleted the message
+      def active_local_participants
+        recipients = Member.s(%{SELECT DISTINCT m.* FROM members m
+                                JOIN accounts a ON (a.id = m.account_id)
+                                JOIN message_recipients mr ON (m.id = mr.member_id)
+                                WHERE mr.message_id = ?
+                                AND NOT mr.deleted
+                               }, self.id)
+        if ! self.deleted && self.sender.local?
+          ( recipients + [self.sender] ).uniq
+        else
+          recipients
+        end
+      end
+
+      def delete_for_participant(local_member)
+        # Delete the message for the local participant only, i.e. by
+        # removing the assignment.  If this is the last local
+        # participant, delete the whole message.  Note that other
+        # recipients / the sender will not see a change in the number
+        # of recipients when one of the recipients "deletes" their
+        # "copy" of the Message
+        participants = active_local_participants
+
+        # not authorised to delete
+        return  if participants.empty?
+
+        if participants == [local_member]
+          # This is the only member interested in this message; delete it completely.
+          self.delete_cascade
+        else
+          # there are other local members with a pointer to the
+          # message. Only mark as deleted for this recipient.
+          DB.dbh[ "UPDATE message_recipients SET deleted=true WHERE message_id = ? AND member_id = ?",
+                  self.id, local_member.id ].get
+          if local_member == self.sender
+            self.deleted = true
+            self.save
+          end
+        end
+        return true
+      end
+
+      def visible_to?(account)
+        self.sender == account.member || recipients.include?(account.member)
+      end
+
+      def self.create_with_recipients(args)
+        message = self.create(
+          sender_member_id: args[:sender_member_id],
+          remote_id: args[:remote_id],
+          text: args[:text]
+        )
+        sender_member = Model::Member[ args[:sender_member_id].to_i ]
+
+        recipient_member_ids = Array(args[:recipient_member_ids])
+        recipient_member_ids.each do |member_id|
+          DB.dbh[ "INSERT INTO message_recipients ( message_id, member_id ) VALUES ( ?, ? )", message.id, member_id.to_i ].get
+          m = Member[member_id]
+          if m.account
+            a = m.account
+            if ! a.ignoring?(sender_member)
+              a.notify_about  'type' => 'message', 'message_id' => message.id
+              if a.email && a.settings.forward_dms_via_email
+                message.forward_via_email(a)
+              end
+            end
+          end
+        end
+        message.distribute  if sender_member.local?
+        message
+      end
+
+      def delete_cascade
+        DB.dbh[ "SELECT delete_cascade_message(?)", self.id ].get
+      end
+
+      def to_hash
+        {
+          'id'           => self.id,
+          'time_created' => self.time_created,
+          'to'           => self.recipients.map(&:name_display),
+          'text'         => self.text,
+        }
+      end
+    end
+  end
+end

data/lib/libertree/model/node.rb

@@ -0,0 +1,22 @@
+module Libertree
+  module Model
+    class Node < Sequel::Model(:nodes)
+      ACCESS_MODELS = [ :open,
+                        :presence,
+                        :roster,
+                        :authorize,
+                        :whitelist ]
+      def affiliations
+        NodeAffiliation.where(:node_id => self.id)
+      end
+
+      def subs(jid=nil)
+        NodeSubscription.for(jid).where(:node_id => self.id)
+      end
+
+      def local_subscribers
+        self.subs.join(:accounts, :id => :account_id)
+      end
+    end
+  end
+end

data/lib/libertree/model/node_affiliation.rb

@@ -0,0 +1,14 @@
+module Libertree
+  module Model
+    class NodeAffiliation < Sequel::Model(:affiliations)
+      TYPES = [ :owner,
+                :publisher,
+                :'publish-only',
+                :member,
+                :none,
+                :outcast ]
+
+      many_to_one :node
+    end
+  end
+end

data/lib/libertree/model/node_subscription.rb

@@ -0,0 +1,23 @@
+module Libertree
+  module Model
+    class NodeSubscription < Sequel::Model(:node_subscriptions)
+      STATES = [ :none,
+                 :pending,
+                 :unconfigured,
+                 :subscribed ]
+
+      many_to_one :node
+
+      def self.for(jid_or_host)
+        return self  unless jid_or_host
+        jid_or_host = jid_or_host.to_s
+        if jid_or_host.include?('@')
+          self.where(jid: jid_or_host)
+        else
+          host_pattern = self.where.escape_like(jid_or_host.to_s)
+          self.where(Sequel.like(:jid, "%@#{host_pattern}"))
+        end
+      end
+    end
+  end
+end

data/lib/libertree/model/notification.rb

@@ -0,0 +1,71 @@
+require 'json'
+
+module Libertree
+  module Model
+    class Notification < Sequel::Model(:notifications)
+      def account
+        @account ||= Account[self.account_id]
+      end
+
+      def data
+        if val = super
+          JSON.parse val
+        end
+      end
+
+      def subject
+        @subject ||= case self.data['type']
+        when 'comment'
+          Libertree::Model::Comment[ self.data['comment_id'] ]
+        when 'comment-like'
+          Libertree::Model::CommentLike[ self.data['comment_like_id'] ]
+        when 'message'
+          Libertree::Model::Message[ self.data['message_id'] ]
+        when 'post-like'
+          Libertree::Model::PostLike[ self.data['post_like_id'] ]
+        when 'springing'
+          Libertree::Model::PoolPost[ self.data['pool_post_id'] ]
+        when 'mention', 'group-post'
+          Libertree::Model::Post[ self.data['post_id'] ]
+        end
+      end
+
+      def self.mark_seen_for_account_and_comment_id(account, comment_ids)
+        data = comment_ids.map {|id| %|{"type":"comment","comment_id":#{id.to_i}}| }
+        data += CommentLike.where(comment_id: comment_ids).
+          map {|like| %|{"type":"comment-like","comment_like_id":#{like.id}}| }
+
+        self.where(account_id: account.id, data: data).update(seen: true)
+        account.dirty
+      end
+
+      def self.mark_seen_for_account_and_post(account, post)
+        data = post.likes.map {|like| %|{"type":"post-like","post_like_id":#{like.id.to_i}}| }
+        self.where(account_id: account.id, data: data).update(seen: true)
+        account.dirty
+      end
+
+      def self.mark_seen_for_account_and_message(account, message)
+        self.where("account_id = ? AND data = ?", account.id, %|{"type":"message","message_id":#{message.id}}|).
+          update(seen: true)
+        account.dirty
+      end
+
+      def self.mark_seen_for_account(account, notification_ids)
+        if notification_ids[0] == 'all'
+          self.where(account_id: account.id).update(seen: true)
+        else
+          self.where(account_id: account.id, id: notification_ids).
+            update(seen: true)
+        end
+        account.dirty
+      end
+
+      def self.mark_unseen_for_account(account, notification_ids)
+        self.where(account_id: account.id, id: notification_ids).
+          update(seen: false)
+        account.dirty
+      end
+    end
+  end
+end

data/lib/libertree/model/pool-post.rb

@@ -0,0 +1,17 @@
+module Libertree
+  module Model
+    class PoolPost < Sequel::Model(:pools_posts)
+      def pool
+        Pool[self.pool_id]
+      end
+
+      def post
+        Post[self.post_id]
+      end
+
+      def member
+        pool.member
+      end
+    end
+  end
+end

data/lib/libertree/model/pool.rb

@@ -0,0 +1,172 @@
+module Libertree
+  module Model
+    class Pool < Sequel::Model(:pools)
+      include IsRemoteOrLocal
+
+      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
+
+      def create_pool_delete_job
+        Libertree::Model::Job.create_for_forests(
+          {
+            task: 'request:POOL-DELETE',
+            params: { 'pool_id' => self.id, }
+          },
+          *self.forests
+        )
+      end
+
+      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
+
+      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
+
+      def before_destroy
+        if self.local? && self.sprung?
+          self.create_pool_delete_job
+        end
+        super
+      end
+
+      def member
+        @member ||= Member[self.member_id]
+      end
+
+      # TODO: DRY up with member.posts?
+      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
+
+      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
+
+      # NOTE: deletion is NOT distributed
+      def delete_cascade
+        DB.dbh[ "SELECT delete_cascade_pool(?)", self.id ].get
+      end
+
+      def dirty
+        @posts = nil
+        self
+      end
+
+      def notify_about_springing(pool_post)
+        pool = pool_post.pool
+        return  if ! pool.sprung
+
+        post = pool_post.post
+        local_post_author = post.member.account
+        pool_owner = pool.member.account
+
+        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
+
+      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
+
+      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
+
+      def sprung?
+        self.sprung
+      end
+    end
+  end
+end