From 0518492158af247f3b99a8f27f4498d1bcc91117 Mon Sep 17 00:00:00 2001 From: Eugen Rochko Date: Sun, 12 Feb 2017 00:48:53 +0100 Subject: Stop trying to shoehorn all Salmon updates into the poor database-connected StreamEntry model. Simply render Salmon slaps as they are needed --- app/services/authorize_follow_service.rb | 33 +++++++++++++++++++--- app/services/block_service.rb | 23 +++++++++++++++- app/services/favourite_service.rb | 31 +++++++++++++++++---- app/services/follow_service.rb | 47 ++++++++++++++++++++++++++------ app/services/reject_follow_service.rb | 33 +++++++++++++++++++--- app/services/unblock_service.rb | 25 +++++++++++++++-- app/services/unfavourite_service.rb | 31 +++++++++++++++++---- app/services/unfollow_service.rb | 25 +++++++++++++++-- 8 files changed, 214 insertions(+), 34 deletions(-) (limited to 'app/services') diff --git a/app/services/authorize_follow_service.rb b/app/services/authorize_follow_service.rb index 5370b4b61..2e0b6d26c 100644 --- a/app/services/authorize_follow_service.rb +++ b/app/services/authorize_follow_service.rb @@ -1,12 +1,37 @@ # frozen_string_literal: true class AuthorizeFollowService < BaseService - include StreamEntryRenderer - def call(source_account, target_account) follow_request = FollowRequest.find_by!(account: source_account, target_account: target_account) follow_request.authorize! - NotificationWorker.perform_async(stream_entry_to_xml(follow_request.stream_entry), target_account.id, source_account.id) unless source_account.local? - follow_request.stream_entry.destroy + NotificationWorker.perform_async(build_xml(follow_request), target_account.id, source_account.id) unless source_account.local? + end + + private + + def build_xml(follow_request) + Nokogiri::XML::Builder.new do |xml| + entry(xml, true) do + author(xml) do + include_author xml, follow_request.target_account + end + + object_type xml, :activity + verb xml, :authorize + + target(xml) do + author(xml) do + include_author xml, follow_request.account + end + + object_type xml, :activity + verb xml, :request_friend + + target(xml) do + include_author xml, follow_request.target_account + end + end + end + end.to_xml end end diff --git a/app/services/block_service.rb b/app/services/block_service.rb index 095d2a8eb..bcd8c44c4 100644 --- a/app/services/block_service.rb +++ b/app/services/block_service.rb @@ -12,6 +12,27 @@ class BlockService < BaseService block = account.block!(target_account) BlockWorker.perform_async(account.id, target_account.id) - NotificationWorker.perform_async(stream_entry_to_xml(block.stream_entry), account.id, target_account.id) unless target_account.local? + NotificationWorker.perform_async(build_xml(block), account.id, target_account.id) unless target_account.local? + end + + private + + def build_xml(block) + Nokogiri::XML::Builder.new do |xml| + entry(xml, true) do + title xml, "#{block.account.acct} no longer wishes to interact with #{block.target_account.acct}" + + author(xml) do + include_author xml, block.account + end + + object_type xml, :activity + verb xml, :block + + target(xml) do + include_author xml, block.target_account + end + end + end.to_xml end end diff --git a/app/services/favourite_service.rb b/app/services/favourite_service.rb index ce1722b77..11585250f 100644 --- a/app/services/favourite_service.rb +++ b/app/services/favourite_service.rb @@ -1,8 +1,6 @@ # frozen_string_literal: true class FavouriteService < BaseService - include StreamEntryRenderer - # Favourite a status and notify remote user # @param [Account] account # @param [Status] status @@ -12,14 +10,37 @@ class FavouriteService < BaseService favourite = Favourite.create!(account: account, status: status) - Pubsubhubbub::DistributionWorker.perform_async(favourite.stream_entry.id) - if status.local? NotifyService.new.call(favourite.status.account, favourite) else - NotificationWorker.perform_async(stream_entry_to_xml(favourite.stream_entry), account.id, status.account_id) + NotificationWorker.perform_async(build_xml(favourite), account.id, status.account_id) end favourite end + + private + + def build_xml(favourite) + Nokogiri::XML::Builder.new do |xml| + entry(xml, true) do + title xml, "#{favourite.account.acct} favourited a status by #{favourite.status.account.acct}" + + author(xml) do + include_author xml, favourite.account + end + + object_type xml, :activity + verb xml, :favourite + + target(xml) do + author(xml) do + include_author xml, favourite.status.account + end + + include_entry xml, favourite.status.stream_entry + end + end + end.to_xml + end end diff --git a/app/services/follow_service.rb b/app/services/follow_service.rb index ac0392d16..5a4250636 100644 --- a/app/services/follow_service.rb +++ b/app/services/follow_service.rb @@ -7,7 +7,7 @@ class FollowService < BaseService # @param [Account] source_account From which to follow # @param [String] uri User URI to follow in the form of username@domain def call(source_account, uri) - target_account = follow_remote_account_service.call(uri) + target_account = FollowRemoteAccountService.new.call(uri) raise ActiveRecord::RecordNotFound if target_account.nil? || target_account.id == source_account.id || target_account.suspended? raise Mastodon::NotPermitted if target_account.blocking?(source_account) || source_account.blocking?(target_account) @@ -27,7 +27,7 @@ class FollowService < BaseService if target_account.local? NotifyService.new.call(target_account, follow_request) else - NotificationWorker.perform_async(stream_entry_to_xml(follow_request.stream_entry), source_account.id, target_account.id) + NotificationWorker.perform_async(build_follow_request_xml(follow_request), source_account.id, target_account.id) AfterRemoteFollowRequestWorker.perform_async(follow_request.id) end @@ -40,13 +40,12 @@ class FollowService < BaseService if target_account.local? NotifyService.new.call(target_account, follow) else - subscribe_service.call(target_account) unless target_account.subscribed? - NotificationWorker.perform_async(stream_entry_to_xml(follow.stream_entry), source_account.id, target_account.id) + SubscribeService.new.call(target_account) unless target_account.subscribed? + NotificationWorker.perform_async(build_follow_xml(follow), source_account.id, target_account.id) AfterRemoteFollowWorker.perform_async(follow.id) end MergeWorker.perform_async(target_account.id, source_account.id) - Pubsubhubbub::DistributionWorker.perform_async(follow.stream_entry.id) follow end @@ -55,11 +54,41 @@ class FollowService < BaseService Redis.current end - def follow_remote_account_service - @follow_remote_account_service ||= FollowRemoteAccountService.new + def build_follow_request_xml(follow_request) + Nokogiri::XML::Builder.new do |xml| + entry(xml, true) do + title xml, "#{follow_request.account.acct} requested to follow #{follow_request.target_account.acct}" + + author(xml) do + include_author xml, follow_request.account + end + + object_type xml, :activity + verb xml, :request_friend + + target(xml) do + include_author xml, follow_request.target_account + end + end + end.to_xml end - def subscribe_service - @subscribe_service ||= SubscribeService.new + def build_follow_xml(follow) + Nokogiri::XML::Builder.new do |xml| + entry(xml, true) do + title xml, "#{follow.account.acct} started following #{follow.target_account.acct}" + + author(xml) do + include_author xml, follow.account + end + + object_type xml, :activity + verb xml, :follow + + target(xml) do + include_author xml, follow.target_account + end + end + end.to_xml end end diff --git a/app/services/reject_follow_service.rb b/app/services/reject_follow_service.rb index a17d6a7be..ac92ad5f7 100644 --- a/app/services/reject_follow_service.rb +++ b/app/services/reject_follow_service.rb @@ -1,12 +1,37 @@ # frozen_string_literal: true class RejectFollowService < BaseService - include StreamEntryRenderer - def call(source_account, target_account) follow_request = FollowRequest.find_by!(account: source_account, target_account: target_account) follow_request.reject! - NotificationWorker.perform_async(stream_entry_to_xml(follow_request.stream_entry), target_account.id, source_account.id) unless source_account.local? - follow_request.stream_entry.destroy + NotificationWorker.perform_async(build_xml(follow_request), target_account.id, source_account.id) unless source_account.local? + end + + private + + def build_xml(follow_request) + Nokogiri::XML::Builder.new do |xml| + entry(xml, true) do + author(xml) do + include_author xml, follow_request.target_account + end + + object_type xml, :activity + verb xml, :reject + + target(xml) do + author(xml) do + include_author xml, follow_request.account + end + + object_type xml, :activity + verb xml, :request_friend + + target(xml) do + include_author xml, follow_request.target_account + end + end + end + end.to_xml end end diff --git a/app/services/unblock_service.rb b/app/services/unblock_service.rb index 84b1050c1..4ff180747 100644 --- a/app/services/unblock_service.rb +++ b/app/services/unblock_service.rb @@ -1,12 +1,31 @@ # frozen_string_literal: true class UnblockService < BaseService - include StreamEntryRenderer - def call(account, target_account) return unless account.blocking?(target_account) unblock = account.unblock!(target_account) - NotificationWorker.perform_async(stream_entry_to_xml(unblock.stream_entry), account.id, target_account.id) unless target_account.local? + NotificationWorker.perform_async(build_xml(unblock), account.id, target_account.id) unless target_account.local? + end + + private + + def build_xml(block) + Nokogiri::XML::Builder.new do |xml| + entry(xml, true) do + title xml, "#{block.account.acct} no longer blocks #{block.target_account.acct}" + + author(xml) do + include_author xml, block.account + end + + object_type xml, :activity + verb xml, :unblock + + target(xml) do + include_author xml, block.target_account + end + end + end.to_xml end end diff --git a/app/services/unfavourite_service.rb b/app/services/unfavourite_service.rb index 04293ee08..b79b8a938 100644 --- a/app/services/unfavourite_service.rb +++ b/app/services/unfavourite_service.rb @@ -1,16 +1,37 @@ # frozen_string_literal: true class UnfavouriteService < BaseService - include StreamEntryRenderer - def call(account, status) favourite = Favourite.find_by!(account: account, status: status) favourite.destroy! - unless status.local? - NotificationWorker.perform_async(stream_entry_to_xml(favourite.stream_entry), account.id, status.account_id) - end + NotificationWorker.perform_async(build_xml(favourite), account.id, status.account_id) unless status.local? favourite end + + private + + def build_xml(favourite) + Nokogiri::XML::Builder.new do |xml| + entry(xml, true) do + title xml, "#{favourite.account.acct} no longer favourites a status by #{favourite.status.account.acct}" + + author(xml) do + include_author xml, favourite.account + end + + object_type xml, :activity + verb xml, :unfavourite + + target(xml) do + author(xml) do + include_author xml, favourite.status.account + end + + include_entry xml, favourite.status.stream_entry + end + end + end.to_xml + end end diff --git a/app/services/unfollow_service.rb b/app/services/unfollow_service.rb index 178da4da3..8982b1c19 100644 --- a/app/services/unfollow_service.rb +++ b/app/services/unfollow_service.rb @@ -1,14 +1,33 @@ # frozen_string_literal: true class UnfollowService < BaseService - include StreamEntryRenderer - # Unfollow and notify the remote user # @param [Account] source_account Where to unfollow from # @param [Account] target_account Which to unfollow def call(source_account, target_account) follow = source_account.unfollow!(target_account) - NotificationWorker.perform_async(stream_entry_to_xml(follow.stream_entry), source_account.id, target_account.id) unless target_account.local? + NotificationWorker.perform_async(build_xml(follow), source_account.id, target_account.id) unless target_account.local? UnmergeWorker.perform_async(target_account.id, source_account.id) end + + private + + def build_xml(follow) + Nokogiri::XML::Builder.new do |xml| + entry(xml, true) do + title xml, "#{follow.account.acct} is no longer following #{follow.target_account.acct}" + + author(xml) do + include_author xml, follow.account + end + + object_type xml, :activity + verb xml, :unfollow + + target(xml) do + include_author xml, follow.target_account + end + end + end.to_xml + end end -- cgit