loco-rails 4.1.1 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6efc2ac92aece905588e66392e372f7fba0414d542b45a659cf6637e25932b4
-  data.tar.gz: e53dbee6931104ceb192dcb677b2a927528629c620fef5a68c30afb53ff5397a
+  metadata.gz: 3b3b768bf72d198a530c47e9aab5060b783c647f0ff97eb54c3ab5549499bf7c
+  data.tar.gz: 2f10baeb21193dc8a3bf0abb1038847224fe4aef5663c21dadf74a1dfb821486
 SHA512:
-  metadata.gz: a196c6b188cd04c205862ee75d1dbe35ec14607a2a49ffa659013c116789d406faaf6521861dad623cbe6ac5356155b35a91fa73967f999142007b553e3a9a77
-  data.tar.gz: '0692ad504f2455e620352adefdf38e9327c9212601578ed9dde443c23d40a0addcfb7431950c8ad04cf47c4c82f18a472363209fc7e64c3a4c5e860933e08398'
+  metadata.gz: 54a025a862ecb19b028a8e86cc14832aa8565656250914431cc0cffc8f0e7eb361d9ea606fa922f3f7fcc655fc47524055f79547e2aeb37874be011e25883912
+  data.tar.gz: 175abf6fda5e84783a2c38138cd08a62a3c7a48e0ff7b04c1e5b80d4053d52f3ce6dac0e532e8fb4b0e809e540c62975d846e68ccab3f835329e7c5a37528daf

data/app/channels/loco/notification_center_channel.rb

@@ -5,61 +5,37 @@ module Loco
     def subscribed
       return unless loco_permissions.is_a?(Array)
 
-      stream_for_resources
-      return if loco_permissions.compact.size > 1
+      @uuid, *signed_in_resources = PermissionsPresenter.signed_in(loco_permissions)
+      return unless @uuid.is_a?(String)
 
-      SenderJob.perform_later @uuid, loco: { start_ajax_polling: true }
+      stream_from("loco:notification_center:#{@uuid}")
+      broadcast_to(@uuid, loco: { uuid: @uuid })
+      signed_in_resources.each { |resource| WsConnectionManager.new(resource).add(@uuid) }
     end
 
     def unsubscribed
-      loco_permissions.each do |resource|
-        next if resource.nil? || resource.is_a?(String)
-
-        UuidJob.perform_later serialize_resource(resource), @uuid, 'del'
+      PermissionsPresenter.signed_in(loco_permissions, except: :uuid).each do |resource|
+        WsConnectionManager.new(resource).del(@uuid)
       end
     end
 
-    def receive(data)
-      update_connections if data['loco'] && data['loco']['connection_check']
-      NotificationCenter.new.received_message permissions, data
-    end
-
-    protected
-
-    def stream_for_resources
-      loco_permissions.compact.each do |resource|
-        if resource.is_a? String
-          @uuid = resource
-          stream_for_resource resource
-          SenderJob.perform_later @uuid, loco: { uuid: @uuid }
-        else
-          UuidJob.perform_later serialize_resource(resource), @uuid, 'add'
-          stream_for_resource resource
-        end
+    def receive(payload)
+      if payload.dig('loco', 'pong')
+        update_connections
+        broadcast_to(@uuid, loco: { ping: true })
       end
-    end
+      return if payload.keys == ['loco']
 
-    def stream_for_resource(resource)
-      identifier = WsConnectionManager.new(resource).identifier
-      stream_from "loco:notification_center:#{identifier}"
+      indexed_permissions = PermissionsPresenter.indexed(loco_permissions)
+      NotificationCenter.new.received_message(indexed_permissions, payload)
     end
 
-    def permissions
-      loco_permissions.compact.index_by do |o|
-        o.class.name.downcase.to_sym
-      end
-    end
+    protected
 
     def update_connections
-      permissions.each do |key, val|
-        next if key == :string
-
-        UuidJob.perform_later serialize_resource(val), @uuid, 'update'
+      PermissionsPresenter.indexed(loco_permissions, except: :uuid).each do |_, resource|
+        WsConnectionManager.new(resource).update(@uuid)
       end
     end
-
-    def serialize_resource(resource)
-      { 'class' => resource.class.name, 'id' => resource.id }
-    end
   end
 end

data/app/controllers/loco/notification_center_controller.rb

@@ -21,41 +21,16 @@ module Loco
         render json: [[], Time.current.iso8601(6)]
         return
       end
-      fetcher = Notification::Fetcher.new notif_fetcher_args
-      render json: [
-        fetcher.formatted_notifications,
-        fetcher.next_sync_time.iso8601(6)
-      ]
-    end
-
-    def notif_fetcher_args
-      {
-        synced_at: params[:synced_at],
-        permissions: permissions,
-        recipient_token: params[:token]
-      }
+      fetcher = Notification::Fetcher.new({ synced_at: params[:synced_at],
+                                            permissions: permissions,
+                                            recipient_token: params[:token] })
+      render json: [fetcher.formatted_notifications, fetcher.next_sync_time.iso8601(6)]
     end
 
     def permissions
-      return [] unless defined? loco_permissions
-      return loco_permissions if params[:uuid].blank?
-
-      process_loco_permissions
-    end
+      return [] unless defined?(loco_permissions)
 
-    def process_loco_permissions
-      resources_to_del = []
-      resources_to_add = []
-      loco_permissions.each do |resource|
-        next if resource.nil?
-
-        ws_conn_manager = WsConnectionManager.new resource
-        next unless ws_conn_manager.connected?(params[:uuid])
-
-        resources_to_del << resource
-        resources_to_add << resource.class
-      end
-      loco_permissions - resources_to_del + resources_to_add.uniq
+      loco_permissions
     end
   end
 end

data/app/jobs/loco/sender_job.rb

@@ -5,7 +5,7 @@ module Loco
     queue_as :loco
 
     def perform(recipient, data)
-      Sender.new(recipient, data).emit
+      Sender.(recipient, data)
     end
   end
 end

data/app/models/loco/notification.rb

@@ -2,6 +2,9 @@
 
 module Loco
   class Notification < ApplicationRecord
+    FOR_OBJ_SQL_TMPL = 'recipient_class = ? AND recipient_id = ?'
+    FOR_CLASS_SQL_TMPL = 'recipient_class = ? AND recipient_id IS NULL'
+
     attr_reader :obj
 
     serialize :data, JSON
@@ -31,9 +34,9 @@ module Loco
       return if val.nil?
       return if val == :all
 
-      if val.is_a? String
+      if val.is_a?(String)
         self.recipient_token = val
-      elsif val.instance_of? Class
+      elsif val.instance_of?(Class)
         self.recipient_class = val.to_s
       else
         self.recipient_class = val.class.name
@@ -41,17 +44,14 @@ module Loco
       end
     end
 
-    def recipient(opts = {})
-      return recipient_token if recipient_token
-      return unless regular_recipient?
-      return class_recipient unless recipient_id
-
-      obj_recipient opts[:shallow]
-    end
-
-    def prepare
-      set_event
-      set_data
+    def recipient(shallow: false)
+      if !recipient_token.nil?
+        recipient_token
+      elsif regular_recipient?
+        init_recipient(shallow)
+      elsif !recipient_class.nil?
+        recipient_class.constantize
+      end
     end
 
     def compact
@@ -61,41 +61,42 @@ module Loco
     private
 
     def regular_recipient?
-      recipient_class && recipient_id
+      !recipient_class.nil? && !recipient_id.nil?
     end
 
-    def class_recipient
-      recipient_class.constantize
-    end
-
-    def obj_recipient(shallow = false)
+    def init_recipient(shallow)
       if shallow
-        recipient_class.constantize.new id: recipient_id
+        recipient_class.constantize.new(id: recipient_id)
       else
-        recipient_class.constantize.find recipient_id
+        recipient_class.constantize.find(recipient_id)
       end
     end
 
+    def prepare
+      set_event
+      set_data
+    end
+
     def set_event
       return if event.present?
-      return if obj.instance_of? Class
+      return if obj.instance_of?(Class)
 
-      if obj.new_record?
-        self.event = 'creating'
-      else
-        set_event_for_persisted_obj
-      end
+      self.event = if obj.new_record?
+                     'creating'
+                   else
+                     event_for_persisted_obj
+                   end
     end
 
-    def set_event_for_persisted_obj
-      self.event = obj.created_at == obj.updated_at ? 'created' : 'updated'
+    def event_for_persisted_obj
+      obj.created_at == obj.updated_at ? 'created' : 'updated'
     end
 
     def set_data
       self.data ||= {}
       return if obj.nil?
 
-      self.data.merge!(id: obj.id)
+      self.data = data.merge(id: obj.id)
     end
   end
 end

data/app/services/loco/notification/fetcher.rb

@@ -5,17 +5,12 @@ module Loco
     class Fetcher
       attr_accessor :max_size
 
-      def initialize(
-        synced_at:,
-        permissions: [],
-        recipient_token: nil,
-        max_size: nil
-      )
-        @synced_at = synced_at
-        @permissions = permissions
-        @recipient_token = recipient_token
+      def initialize(opts)
+        @synced_at = opts[:synced_at]
+        @permissions = (opts[:permissions] || []).compact
+        @recipient_token = opts[:recipient_token]
         @notifications = nil
-        @max_size = max_size || Loco::Config.notifications_size
+        @max_size = opts[:max_size] || Loco::Config.notifications_size
       end
 
       def formatted_notifications
@@ -56,17 +51,11 @@ module Loco
           recipient_class: nil,
           recipient_id: nil,
           recipient_token: nil
-        ).first max_size
+        ).first(max_size)
       end
 
       def notifications_behind_permissions
-        notifications = []
-        @permissions.each do |resource|
-          next unless resource
-
-          notifications += notification_for_resource resource
-        end
-        notifications
+        @permissions.inject([]) { |arr, resource| arr + notification_for_resource(resource) }
       end
 
       def notifications_behind_token
@@ -74,15 +63,13 @@ module Loco
       end
 
       def notification_for_resource(resource)
-        if resource.instance_of? Class
-          sql = 'recipient_class = ? AND recipient_id IS NULL'
-          return default_scope.where(sql, resource.to_s).first max_size
+        if resource.instance_of?(Class)
+          return default_scope.where(Notification::FOR_CLASS_SQL_TMPL, resource.to_s)
+                              .first(max_size)
         end
         klass = resource.class.name
-        cond1 = '(recipient_class = ? AND recipient_id = ?)'
-        cond2 = '(recipient_class = ? AND recipient_id IS NULL)'
-        sql = "#{cond1} OR #{cond2}"
-        default_scope.where(sql, klass, resource.id, klass).first max_size
+        sql = "(#{Notification::FOR_OBJ_SQL_TMPL}) OR (#{Notification::FOR_CLASS_SQL_TMPL})"
+        default_scope.where(sql, klass, resource.id, klass).first(max_size)
       end
     end
   end

data/lib/generators/loco/file_injector/templates/connection.rb

@@ -1,6 +1,7 @@
     identified_by :loco_permissions
 
     def connect
+      reject_unauthorized_connection unless current_user || current_admin
       # loco_permissions should be the same as in application_controller.rb
       # + SecureRandom.uuid is mandatory at 1st position
       self.loco_permissions = [SecureRandom.uuid, current_user, current_admin]

data/lib/loco-rails.rb

@@ -8,9 +8,12 @@ require 'loco/emitter'
 require 'loco/engine'
 require 'loco/helpers'
 require 'loco/hub'
+require 'loco/permissions_presenter'
 require 'loco/sender'
+require 'loco/ws_connection_checker'
 require 'loco/ws_connection_manager'
-require 'loco/ws_connected_resources_manager'
+require 'loco/ws_connection_finder'
+require 'loco/ws_connection_identifier'
 require 'loco/ws_connection_storage'
 
 module Loco

data/lib/loco/broadcaster.rb

@@ -2,99 +2,51 @@
 
 module Loco
   class Broadcaster
-    attr_reader :obj, :event, :recipients, :data, :notifications
-
-    def initialize(obj, event = nil, opts = {})
-      recipient_key = opts[:for] ? :for : :to
-      @obj = obj
-      @event = event
-      @recipients = opts[recipient_key] ? [*opts[recipient_key]] : [nil]
-      @data = opts[:data]
-      @notifications = []
-      @sent_via_ws = 0
-      @conn_res_manager = WsConnectedResourcesManager.new @recipients.compact
-    end
-
-    def emit
-      init_notifications if notifications.empty?
-      send_notifications
-      if notify_about_xhr_notifications?
-        notify_about_xhr_notifications
-      else
-        set_sync_time_via_ws
+    class << self
+      def call(obj, event, recipients: nil, payload: nil)
+        payload ||= {}
+        payload[:loco] = { idempotency_key: SecureRandom.hex }
+        send_notifications(obj, event, process_recipients(recipients), payload)
       end
-    end
 
-    private
+      private
 
-    def init_notifications
-      recipients.each do |recipient|
-        @notifications << Notification.new(
-          obj: obj,
-          event: event,
-          recipient: recipient,
-          data: data
-        )
+      def process_recipients(recipients)
+        recipients = [:all] if recipients.nil?
+        recipients = [recipients] unless recipients.is_a?(Array)
+        recipients = recipients.map { |e| e.nil? ? :all : e }
+        recipients = [:all] if recipients.include?(:all)
+        recipients
       end
-    end
-
-    def send_notifications
-      notifications.each do |notification|
-        notification.save!
-        next if notification.recipient_id.nil?
 
-        shallow_recipient = notification.recipient shallow: true
-        next unless @conn_res_manager.connected? shallow_recipient
-
-        send_via_ws notification
-      end
-    end
-
-    def send_via_ws(notification)
-      recipient = notification.recipient shallow: true
-      data = { loco: { notification: notification.compact } }
-      SenderJob.perform_later recipient, data
-      @sent_via_ws += 1
-    end
-
-    def notify_about_xhr_notifications?
-      @sent_via_ws < notifications.size
-    end
-
-    def notify_about_xhr_notifications
-      uuids = []
-      fetch_identifiers.each do |ident|
-        Loco::WsConnectionManager.new(ident).connected_uuids.each do |uuid|
-          next if uuids.include? uuid
-
-          uuids << uuid
-          SenderJob.perform_later uuid, loco: { xhr_notifications: true }
+      def send_notifications(obj, event, recipients, payload)
+        recipients.each do |recipient|
+          notification = Notification.create!(
+            obj: obj,
+            event: event,
+            recipient: recipient,
+            data: payload
+          )
+          sync_time = notification.created_at.iso8601(6)
+          send_notification(keify_recipient(recipient), notification, sync_time)
         end
       end
-    end
-
-    def set_sync_time_via_ws
-      sync_time = notifications.last.created_at.iso8601(6)
-      notifications.each do |notification|
-        recipient = notification.recipient shallow: true
-        SenderJob.perform_later recipient, loco: { sync_time: sync_time }
-      end
-    end
 
-    def notifications_recipients
-      notifications.map { |n| n.recipient shallow: true }.map do |o|
-        o.instance_of?(Class) ? o.to_s.downcase : nil
+      def keify_recipient(recipient)
+        case recipient
+        when String then { 'token' => recipient }
+        when Class then { 'class' => recipient.name }
+        else recipient
+        end
       end
-    end
 
-    def fetch_identifiers
-      recipients = notifications_recipients
-      uniq_recipients = recipients.compact.uniq
-      Loco::WsConnectedResourcesManager.identifiers.find_all do |str|
-        if recipients.include? nil
-          true
+      def send_notification(recipient, notification, sync_time)
+        if notification.recipient_id
+          Sender.(recipient, loco: { notification: notification.compact })
+          Sender.(recipient, loco: { sync_time: sync_time })
         else
-          uniq_recipients.include? str.split(':').first
+          SenderJob.perform_later(recipient, loco: { notification: notification.compact })
+          SenderJob.perform_later(recipient, loco: { sync_time: sync_time })
         end
       end
     end