fedipub 0.0.1 → 0.10.0

data/app/models/fedipub/activity.rb

@@ -0,0 +1,62 @@
+module Fedipub
+  # Activities can be compared to a log of what happened in the Fediverse.
+  #
+  # Activities from local actors ends in the actors _outboxes_.
+  # Activities form distant actors comes from the actor's _inbox_.
+  # We try to only keep activities _from_ local actors, and external activities _targetting_ local actors.
+  #
+  # See also:
+  #   - https://www.w3.org/TR/activitypub/#outbox
+  #   - https://www.w3.org/TR/activitypub/#inbox
+  class Activity < ApplicationRecord
+    include Fedipub::HasUuid
+
+    belongs_to :entity, polymorphic: true
+    belongs_to :actor
+
+    scope :feed_for, lambda { |actor|
+      actor_ids = []
+      Following.accepted.where(actor: actor).find_each do |following|
+        actor_ids << following.target_actor_id
+      end
+      where(actor_id: actor_ids)
+    }
+
+    after_create_commit :post_to_inboxes
+
+    before_validation :set_default_addressing, on: :create
+
+    serialize :cc, coder: YAML
+    serialize :to, coder: YAML
+    serialize :result, coder: YAML
+    serialize :instrument, coder: YAML
+
+    # Sends an Undo activity to reverse this one.
+    #
+    # Used for unfollowing, unliking, unboosting, etc.
+    #
+    # @return [Fedipub::Activity] the new Undo activity
+    def undo!
+      Activity.create! actor: actor, action: 'Undo', entity: self, to: to, cc: cc
+    end
+
+    private
+
+    # Sets up default public-and-followers addressing unless to and cc are already set
+    #
+    # This retains compatibility with previous behaviour
+    def set_default_addressing
+      return if to.present? || cc.present?
+
+      self.to = [Fediverse::Collection::PUBLIC]
+      self.cc = [
+        actor.followers_url,
+        (entity.try(:followers_url) if entity.try(:local?)),
+      ].compact.uniq
+    end
+
+    def post_to_inboxes
+      NotifyInboxJob.perform_later(self)
+    end
+  end
+end

data/app/models/fedipub/actor.rb

@@ -0,0 +1,306 @@
+require 'fedipub/utils/host'
+require 'fedipub/utils/actor'
+require 'fediverse/webfinger'
+
+module Fedipub
+  # Model storing _distant_ actors and links to local ones.
+  #
+  # To make a model act as an actor, use the `Fedipub::ActorEntity` concern
+  #
+  # See also:
+  #  - https://www.w3.org/TR/activitypub/#actor-objects
+  class Actor < ApplicationRecord # rubocop:disable Metrics/ClassLength
+    class TombstonedError < StandardError; end
+
+    include Fedipub::HasUuid
+    include Fedipub::HandlesDeleteRequests
+    include Fedipub::Likeable
+    include Fedipub::Announceable
+    include Fedipub::ApplicationActor
+
+    validates :federated_url, presence: { unless: -> { entity || application_actor? } }, uniqueness: { unless: :local? }
+    validates :username, presence: { unless: :local? }
+    validates :server, presence: { unless: :local? }
+    validates :inbox_url, presence: { unless: :local? }
+    validates :outbox_url, presence: { unless: :local? }
+    validates :profile_url, presence: { unless: :local? }
+    validates :actor_type, presence: { unless: -> { local? && !application_actor? } }
+    validates :entity_id, uniqueness: { scope: :entity_type }, if: :entity_type
+    validates :entity, presence: true, if: -> { local? && !tombstoned? && !application_actor? }
+
+    belongs_to :entity, polymorphic: true, optional: true
+    # FIXME: Handle this with something like undelete
+    has_many :activities, dependent: :destroy
+    has_many :activities_as_entity, class_name: 'Fedipub::Activity', as: :entity, dependent: :destroy
+    has_many :following_followers, class_name: 'Fedipub::Following', foreign_key: :target_actor_id, dependent: :destroy, inverse_of: :target_actor
+    has_many :following_follows, class_name: 'Fedipub::Following', dependent: :destroy, inverse_of: :actor
+    # Actors following actor
+    has_many :followers, source: :actor, through: :following_followers
+    # Actors followed by actor
+    has_many :follows, source: :target_actor, through: :following_follows
+    belongs_to :host, class_name: 'Fedipub::Host', foreign_key: :server, primary_key: :domain, inverse_of: :actors, optional: true
+
+    # Explicitly explain serialization for MariaDB
+    attribute :extensions, :json
+
+    scope :local, -> { where(local: true) }
+    scope :distant, -> { where(local: false) }
+    scope :tombstoned, -> { where.not(tombstoned_at: nil) }
+    scope :not_tombstoned, -> { where(tombstoned_at: nil) }
+
+    after_create -> { FetchNodeinfoJob.perform_later(server) }, unless: :local?
+
+    on_fedipub_delete_requested -> { tombstone! }
+    on_fedipub_undelete_requested -> { untombstone! }
+
+    def distant?
+      !local?
+    end
+
+    def federated_url
+      use_entity_attributes? || application_actor? ? Fedipub::Engine.routes.url_helpers.server_actor_url(self) : attributes['federated_url'].presence
+    end
+
+    def username
+      return attributes['username'] unless use_entity_attributes?
+
+      entity.send(entity_configuration[:username_field]).to_s
+    end
+
+    def name
+      value = (entity.send(entity_configuration[:name_field]).to_s if use_entity_attributes?)
+
+      value || attributes['name'] || username
+    end
+
+    def server
+      use_entity_attributes? || application_actor? ? Utils::Host.localhost : attributes['server']
+    end
+
+    def actor_type
+      use_entity_attributes? ? entity_configuration[:actor_type] : attributes['actor_type']
+    end
+
+    def inbox_url
+      use_entity_attributes? || application_actor? ? Fedipub::Engine.routes.url_helpers.server_actor_inbox_url(self) : attributes['inbox_url']
+    end
+
+    def outbox_url
+      use_entity_attributes? || application_actor? ? Fedipub::Engine.routes.url_helpers.server_actor_outbox_url(self) : attributes['outbox_url']
+    end
+
+    def followers_url
+      use_entity_attributes? || application_actor? ? Fedipub::Engine.routes.url_helpers.followers_server_actor_url(self) : attributes['followers_url']
+    end
+
+    def followings_url
+      use_entity_attributes? || application_actor? ? Fedipub::Engine.routes.url_helpers.following_server_actor_url(self) : attributes['followings_url']
+    end
+
+    def profile_url
+      return attributes['profile_url'].presence unless use_entity_attributes?
+
+      method = entity_configuration[:profile_url_method]
+      return Fedipub::Engine.routes.url_helpers.server_actor_url self unless method
+
+      Rails.application.routes.url_helpers.send method, [entity]
+    end
+
+    def at_address(prefix: '@')
+      "#{prefix}#{username}@#{server}"
+    end
+
+    def short_at_address
+      use_entity_attributes? ? "@#{username}" : at_address
+    end
+
+    def acct_uri
+      "acct:#{username}@#{server}"
+    end
+
+    # Checks if a given actor follows the current actor
+    #
+    # @return [Fedipub::Following, false]
+    def follows?(actor)
+      list = following_follows.where target_actor: actor
+      return list.first if list.one?
+
+      false
+    end
+
+    # Checks if current actor is followed by the given actor
+    #
+    # @return [Fedipub::Following, false]
+    def followed_by?(actor)
+      list = following_followers.where actor: actor
+      return list.first if list.one?
+
+      false
+    end
+
+    def entity_configuration
+      raise("Entity not configured for #{entity_type}. Did you use \"acts_as_fedipub_actor\"?") unless Fedipub.actor_entity? entity_type
+
+      Fedipub.actor_entity entity_type
+    end
+
+    # Synchronizes actor with distant data
+    #
+    # @raise [ActiveRecord::RecordNotFound] when distant data was not found
+    def sync!
+      if local?
+        Rails.logger.info 'Ignored attempt to sync a local actor'
+        return false
+      end
+
+      response = Fediverse::Webfinger.fetch_actor_url(federated_url)
+      new_attributes = response.attributes.except 'id', 'uuid', 'created_at', 'updated_at', 'local', 'entity_id', 'entity_type'
+
+      update! new_attributes
+    end
+
+    def tombstoned?
+      tombstoned_at.present?
+    end
+
+    def tombstone!
+      Fedipub::Utils::Actor.tombstone! self
+    end
+
+    def untombstone!
+      Fedipub::Utils::Actor.untombstone! self
+    end
+
+    class << self
+      # Searches for an actor from account URI
+      #
+      # @param account [String] Account URI (username@host)
+      # @return [Fedipub::Actor, nil]
+      def find_by_account(account)
+        parts = Fediverse::Webfinger.split_account account
+
+        if Fediverse::Webfinger.local_user? parts
+          actor = find_local_by_username! parts[:username]
+        else
+          actor = find_by username: parts[:username], server: parts[:domain]
+          actor ||= Fediverse::Webfinger.fetch_actor(parts[:username], parts[:domain])
+        end
+
+        actor
+      end
+
+      def find_by_federation_url(federated_url)
+        local_route = Utils::Host.local_route federated_url
+        return find_param(local_route[:id]) if local_route && local_route[:controller] == 'fedipub/server/actors' && local_route[:action] == 'show'
+
+        actor = find_by federated_url: federated_url
+        return actor if actor
+
+        Fediverse::Webfinger.fetch_actor_url(federated_url)
+      end
+
+      def find_by_federation_url!(federated_url)
+        find_by_federation_url(federated_url).tap do |actor|
+          raise Fedipub::Actor::TombstonedError if actor.tombstoned?
+          raise ActiveRecord::RecordNotFound if actor.nil?
+        end
+      end
+
+      def find_or_create_by_account(account)
+        actor = find_by_account account
+        # Create/update distant actors
+        actor.save! unless actor.local?
+
+        actor
+      end
+
+      def find_or_create_by_federation_url(url)
+        actor = find_by_federation_url url
+        # Create/update distant actors
+        actor.save! unless actor.local?
+
+        actor
+      end
+
+      # Find or create actor from a given actor hash or actor id (actor's URL)
+      def find_or_create_by_object(object)
+        case object
+        when String
+          find_or_create_by_federation_url object
+        when Hash
+          find_or_create_by_federation_url object['id']
+        else
+          raise "Unsupported object type for actor (#{object.class})"
+        end
+      end
+
+      def find_local_by_username(username)
+        actor = nil
+        Fedipub::Configuration.actor_types.each_value do |entity|
+          break if actor.present?
+
+          actor = entity[:class].find_by(entity[:username_field] => username)&.fedipub_actor
+        end
+        return actor if actor
+
+        # Look for pure actors (e.g. the application actor)
+        actor = Fedipub::Actor.local.find_by username: username
+        return actor if actor
+
+        # Last hope: Search for tombstoned actors
+        Fedipub::Actor.local.tombstoned.find_by username: username
+      end
+
+      def find_local_by_username!(username)
+        find_local_by_username(username).tap do |actor|
+          raise ActiveRecord::RecordNotFound if actor.nil?
+        end
+      end
+    end
+
+    def public_key
+      ensure_key_pair_exists!
+      self[:public_key]
+    end
+
+    def private_key
+      ensure_key_pair_exists!
+      self[:private_key]
+    end
+
+    def key_id
+      "#{federated_url}#main-key"
+    end
+
+    private
+
+    def ensure_key_pair_exists!
+      return if self[:private_key].present? || !local?
+
+      update!(generate_key_pair)
+    end
+
+    def generate_key_pair
+      rsa_key = OpenSSL::PKey::RSA.new 2048
+      cipher  = OpenSSL::Cipher.new('AES-128-CBC')
+      {
+        private_key: if Rails.application.credentials.secret_key_base
+                       rsa_key.to_pem(cipher, Rails.application.credentials.secret_key_base)
+                     else
+                       rsa_key.to_pem
+                     end,
+        public_key:  rsa_key.public_key.to_pem,
+      }
+    end
+
+    def use_entity_attributes?
+      local? && !tombstoned? && entity.present?
+    end
+
+    def create_fedipub_activity(action, actor: self, to: nil, cc: nil)
+      return unless local
+
+      Activity.create! actor: actor, action: action, entity: self, to: to, cc: cc
+    end
+  end
+end

data/app/models/fedipub/application_record.rb

@@ -0,0 +1,5 @@
+module Fedipub
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/fedipub/following.rb

@@ -0,0 +1,72 @@
+module Fedipub
+  # Stores following data between actors
+  class Following < ApplicationRecord
+    include Fedipub::HasUuid
+
+    enum :status, pending: 0, accepted: 1
+
+    validates :target_actor_id, uniqueness: { scope: [:actor_id, :target_actor_id] }
+
+    belongs_to :actor
+    belongs_to :target_actor, class_name: 'Fedipub::Actor'
+    has_many :activities, as: :entity, dependent: :destroy
+
+    after_create :after_follow
+    after_create :create_activity, if: :locally_instigated?
+    after_update :after_follow_accepted
+    after_destroy :destroy_activity, if: :locally_instigated?
+
+    define_callbacks :on_fedipub_delete_requested
+
+    set_callback :on_fedipub_delete_requested, -> { destroy! unless locally_instigated? }
+
+    scope :with_actor, ->(actor) { where(actor_id: actor.id).or(where(target_actor_id: actor.id)) }
+
+    def federated_url
+      attributes['federated_url'].presence || Fedipub::Engine.routes.url_helpers.server_actor_following_url(actor_id: actor.to_param, id: to_param)
+    end
+
+    def accept!
+      update! status: :accepted
+      Activity.create! actor: target_actor, action: 'Accept', entity: self, to: [actor.federated_url]
+    end
+
+    def follow_activity
+      Activity.find_by actor: actor, action: 'Follow', entity: target_actor
+    end
+
+    class << self
+      def new_from_account(account, actor:)
+        target_actor = Actor.find_or_create_by_account account
+        new actor: actor, target_actor: target_actor
+      end
+    end
+
+    private
+
+    def locally_instigated?
+      actor.local?
+    end
+
+    def after_follow
+      return unless target_actor&.entity
+
+      target_actor.entity.class.send(:dispatch_callback, :after_followed, target_actor.entity, self)
+    end
+
+    def after_follow_accepted
+      return unless status_previously_changed? && status == 'accepted'
+      return unless actor&.entity
+
+      actor.entity.class.send(:dispatch_callback, :after_follow_accepted, actor.entity, self)
+    end
+
+    def create_activity
+      Activity.create! actor: actor, action: 'Follow', entity: target_actor, to: [target_actor.federated_url]
+    end
+
+    def destroy_activity
+      follow_activity&.undo!
+    end
+  end
+end

data/app/models/fedipub/host.rb

@@ -0,0 +1,48 @@
+require 'fediverse/node_info'
+
+module Fedipub
+  class Host < ApplicationRecord
+    attribute :protocols, :json
+    attribute :services, :json
+
+    validates :domain, presence: true, allow_blank: false, uniqueness: true
+
+    # No "dependent" option here as this is not a hard reference, and we want to keep the actors if the host gets deleted
+    has_many :actors, class_name: 'Fedipub::Actor', primary_key: :domain, foreign_key: :server, inverse_of: :host # rubocop:disable Rails/HasManyOrHasOneDependent
+
+    scope :same_app, -> { where software_name: Configuration.app_name }
+    scope :same_app_and_version, -> { same_app.where app_version: Configuration.app_version }
+
+    def same_app?
+      software_name == Configuration.app_name
+    end
+
+    def same_app_and_version?
+      software_name == Configuration.app_name && app_version == Configuration.app_version
+    end
+
+    # Update from remote data
+    def sync!
+      update! Fediverse::NodeInfo.fetch(domain)
+    end
+
+    class << self
+      # Creates or update a Host
+      #
+      # @param domain              [String] Domain to check
+      # @param min_update_interval [Integer, ActiveSupport::Duration] Minimum amount of seconds since the last update to fetch fresh data
+      def create_or_update(domain, min_update_interval: 0)
+        entry = find_or_initialize_by domain: domain
+        return if min_update_interval && entry.persisted? && (entry.updated_at + min_update_interval) > Time.current
+
+        entry.sync!
+
+        entry
+      rescue Fediverse::NodeInfo::NoActivityPubError
+        Rails.logger.info { "#{domain} does not provide ActivityPub service" }
+      rescue Fedipub::Utils::JsonRequest::UnhandledResponseStatus, Faraday::SSLError => e
+        Rails.logger.info { "Error connecting to #{domain}: '#{e.message}'" }
+      end
+    end
+  end
+end

data/app/policies/fedipub/client/activity_policy.rb

@@ -0,0 +1,9 @@
+module Fedipub
+  module Client
+    class ActivityPolicy < Fedipub::FedipubPolicy
+      def feed?
+        user_with_actor?
+      end
+    end
+  end
+end

data/app/policies/fedipub/client/actor_policy.rb

@@ -0,0 +1,15 @@
+module Fedipub
+  module Client
+    class ActorPolicy < Fedipub::FedipubPolicy
+      def lookup?
+        true
+      end
+
+      class Scope < Scope
+        def resolve
+          scope
+        end
+      end
+    end
+  end
+end

data/app/policies/fedipub/client/following_policy.rb

@@ -0,0 +1,35 @@
+module Fedipub
+  module Client
+    class FollowingPolicy < Fedipub::FedipubPolicy
+      def show?
+        in_following?
+      end
+
+      def destroy?
+        in_following?
+      end
+
+      def accept?
+        in_following? && @record.target_actor_id == @user.fedipub_actor.id
+      end
+
+      def follow?
+        create?
+      end
+
+      class Scope < Scope
+        def resolve
+          scope.with_actor(@user.fedipub_actor)
+        end
+      end
+
+      private
+
+      def in_following?
+        return false unless user_with_actor?
+
+        @record.actor_id == @user.fedipub_actor&.id || @record.target_actor_id == @user.fedipub_actor&.id
+      end
+    end
+  end
+end

data/app/policies/fedipub/fedipub_policy.rb

@@ -0,0 +1,63 @@
+module Fedipub
+  class FedipubPolicy
+    attr_reader :user, :record
+
+    def initialize(user, record)
+      @user = user
+      @record = record
+    end
+
+    def index?
+      true
+    end
+
+    def show?
+      true
+    end
+
+    def create?
+      @user.present?
+    end
+
+    def new?
+      create?
+    end
+
+    def update?
+      owner?
+    end
+
+    def edit?
+      update?
+    end
+
+    def destroy?
+      owner?
+    end
+
+    class Scope
+      attr_reader :user, :scope
+
+      def initialize(user, scope)
+        @user = user
+        @scope = scope
+      end
+
+      def resolve
+        scope.all
+      end
+    end
+
+    private
+
+    def owner?
+      return false unless @user
+
+      @record.actor_id == @user.fedipub_actor.id
+    end
+
+    def user_with_actor?
+      @user && Fedipub.actor_entity?(@user) && !!@user.fedipub_actor
+    end
+  end
+end

data/app/policies/fedipub/server/activity_policy.rb

@@ -0,0 +1,9 @@
+module Fedipub
+  module Server
+    class ActivityPolicy < Fedipub::FedipubPolicy
+      def outbox?
+        true
+      end
+    end
+  end
+end

data/app/policies/fedipub/server/actor_policy.rb

@@ -0,0 +1,23 @@
+module Fedipub
+  module Server
+    class ActorPolicy < Fedipub::FedipubPolicy
+      def show?
+        @record.local?
+      end
+
+      def following?
+        true
+      end
+
+      def followers?
+        true
+      end
+
+      class Scope < Scope
+        def resolve
+          scope.local
+        end
+      end
+    end
+  end
+end

data/app/policies/fedipub/server/following_policy.rb

@@ -0,0 +1,6 @@
+module Fedipub
+  module Server
+    class FollowingPolicy < Fedipub::FedipubPolicy
+    end
+  end
+end

data/app/policies/fedipub/server/publishable_policy.rb

@@ -0,0 +1,15 @@
+module Fedipub
+  module Server
+    class PublishablePolicy < Fedipub::FedipubPolicy
+      def show?
+        @record.send(@record.fedipub_data_configuration[:should_federate_method])
+      end
+
+      class Scope < Scope
+        def resolve
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/app/views/fedipub/client/activities/_activity.html.erb

@@ -0,0 +1,5 @@
+<div>
+  <b><%= link_to activity.actor.name, fedipub.client_actor_url(activity.actor) %></b>
+  <code><%= activity.action %></code>
+  <!-- < %= link_to activity.entity_type, activity.entity %>-->
+</div>

data/app/views/fedipub/client/activities/_activity.json.jbuilder

@@ -0,0 +1 @@
+json.extract! activity, :id, :entity_id, :entity_type, :action, :actor_id, :created_at

data/app/views/fedipub/client/activities/_index.json.jbuilder

@@ -0,0 +1 @@
+json.array! @activities, partial: 'fedipub/client/activities/activity', as: :activity