panel/app/controllers/api/v1/webhooks/social_inbox_controller.rb

# frozen_string_literal: true

module Api
  module V1
    module Webhooks
      # Recibe webhooks de la Social Inbox
      #
      # @todo Mover todo a un Job que obtenga el objeto remoto antes de
      # instanciar el objeto localmente en lugar de arreglarlo después y
      # poder responder lo más rápido posible el webhook.
      # @see {https://www.w3.org/TR/activitypub/}
      class SocialInboxController < BaseController
        include Api::V1::Webhooks::Concerns::WebhookConcern

        # Cuando una actividad ingresa en la cola de moderación, la
        # recibimos por acá
        #
        # Vamos a recibir Create, Update, Delete, Follow, Undo y obtener
        # el objeto dentro de cada una para guardar un estado asociado
        # al sitio.
        #
        # El objeto del estado puede ser un objeto o une actore,
        # dependiendo de la actividad.
        def moderationqueued
          # Devuelve un error si el token no es válido
          usuarie.present?

          ActivityPub.transaction do
            # Crea todos los registros necesarios y actualiza el estado
            actor.present?
            instance.present?
            object.present?
            activity_pub.present?

            activity.update_activity_pub_state!
          end
        rescue ActiveRecord::RecordInvalid => e
          ExceptionNotifier.notify_exception(e,
                                             data: { site: site.name, usuarie: usuarie.email,
                                                     activity: original_activity })
        ensure
          head :accepted
        end

        # Cuando la Social Inbox acepta una actividad, la recibimos
        # igual y la guardamos por si cambiamos de idea.
        #
        # @todo DRY
        def onapproved
          ActivityPub.transaction do
            actor.present?
            instance.present?
            object.present?
            activity.present?
            activity_pub.approve!
          end

          head :accepted
        end

        # Cuando la Social Inbox rechaza una actividad, la recibimos
        # igual y la guardamos por si cambiamos de idea.
        #
        # @todo DRY
        def onrejected
          ActivityPub.transaction do
            actor.present?
            instance.present?
            object.present?
            activity.present?
            activity_pub.reject!
          end

          head :accepted
        end

        private

        # Si el objeto ya viene incorporado en la actividad o lo tenemos
        # que traer remotamente.
        #
        # @return [Bool]
        def object_embedded?
          @object_embedded ||= original_activity[:object].is_a?(Hash)
        end

        # Encuentra la URI del objeto o falla si no la encuentra.
        #
        # @return [String]
        def object_uri
          @object_uri ||=
            case original_activity[:object]
            when String then original_activity[:object]
            when Hash then original_activity.dig(:object, :id)
            end
        ensure
          raise ActiveRecord::RecordNotFound, 'object id missing' unless @object_uri
        end

        # Atajo a la instancia
        #
        # @return [ActivityPub::Instance]
        def instance
          actor.instance
        end

        # Genera un objeto a partir de la actividad.  Si el objeto ya
        # existe, actualiza su contenido.  Si el objeto no viene
        # incorporado, obtenemos el contenido más tarde.
        #
        # @return [ActivityPub::Object]
        def object
          @object ||= ActivityPub::Object.find_or_initialize_by(uri: object_uri).tap do |o|
            # XXX: Si el objeto es una actividad, esto siempre va a ser
            # Generic
            o.type ||= 'ActivityPub::Object::Generic'
            o.content = original_object if object_embedded?

            o.save!

            # XXX: el objeto necesita ser guardado antes de poder
            # procesarlo
            ActivityPub::FetchJob.perform_later(site: site, object: o) unless object_embedded?
          end
        end

        # Genera el seguimiento del estado del objeto con respecto al
        # sitio.
        #
        # @return [ActivityPub]
        def activity_pub
          @activity_pub ||= site.activity_pubs.find_or_create_by!(site: site, instance: instance, object: object)
        end

        # Crea la actividad y la vincula con el estado
        #
        # @return [ActivityPub::Activity]
        def activity
          @activity ||=
            ActivityPub::Activity
            .type_from(original_activity)
            .find_or_initialize_by(uri: original_activity[:id], activity_pub: activity_pub, actor: actor).tap do |a|
              a.content = original_activity.dup
              a.content[:object] = object.uri
              a.save!
            end
        end

        # Actor, si no hay instancia, la crea en el momento, junto con
        # su estado de moderación.
        #
        # @return [Actor]
        def actor
          @actor ||= ActivityPub::Actor.find_or_initialize_by(uri: original_activity[:actor]).tap do |a|
            unless a.instance
              a.instance = ActivityPub::Instance.find_or_create_by(hostname: URI.parse(a.uri).hostname)

              site.instance_moderations.find_or_create_by(instance: a.instance)

              ActivityPub::InstanceFetchJob.perform_later(site: site, instance: a.instance)
            end

            a.save!

            site.actor_moderations.find_or_create_by(actor: a)

            ActivityPub::ActorFetchJob.perform_later(site: site, actor: a)
          end
        end

        # Descubre la actividad recibida, generando un error si la
        # actividad no está dirigida a nosotres.
        #
        # @todo Validar formato
        # @return [Hash]
        def original_activity
          @original_activity ||= FastJsonparser.parse(request.raw_post).tap do |activity|
            raise '@context missing' unless activity[:@context].presence
            raise 'id missing' unless activity[:id].presence
            raise 'object missing' unless activity[:object].presence
          rescue RuntimeError => e
            raise ActiveRecord::RecordNotFound, e.message
          end
        end

        # @return [Hash,String]
        def original_object
          @original_object ||= original_activity[:object].dup.tap do |o|
            o[:@context] = original_activity[:@context].dup
          end
        end
      end
    end
  end
end