action_cable_notifications 0.1.14 → 0.1.18

data/lib/action_cable_notifications/channel.rb

@@ -0,0 +1,192 @@
+require 'action_cable_notifications/channel_actions.rb'
+
+module ActionCableNotifications
+  module Channel
+    extend ActiveSupport::Concern
+
+    included do
+      # class variables
+      class_attribute :ActionCableNotifications
+
+      self.ActionCableNotifications = {}
+    end
+
+    #
+    # Public methods
+    ################################################################
+
+    #
+    # Process actions sent from the client
+    #
+    # @param [Hash] data Contains command to be executed and its parameters
+    # {
+    #   "collection": "model.model_name.collection"
+    #   "command": "fetch"
+    #   "params": {}
+    # }
+    def action(data)
+      data.deep_symbolize_keys!
+
+      channel_options = self.ActionCableNotifications[data[:collection]]
+      model = channel_options[:model]
+      broadcasting = channel_options[:broadcasting]
+      model_options = model.ActionCableNotificationsOptions[broadcasting]
+
+      params = {
+        model: model,
+        model_options: model_options,
+        params: data[:params]
+      }
+
+      case data[:command]
+      when "fetch"
+        fetch(params)
+      when "create"
+        create(params)
+      when "update"
+        update(params)
+      when "destroy"
+        destroy(params)
+      end
+    end
+
+    def initialize(*args)
+      super
+      @collections = {}
+    end
+
+    def subscribed
+      # XXX Check if this is new connection or a reconection of a
+      # previously active client
+    end
+
+    def unsubscribed
+      stop_all_streams
+    end
+
+    #
+    # Private methods
+    ################################################################
+
+    private
+
+    include ActionCableNotifications::Channel::Actions
+
+    #
+    # Streams notification for ActiveRecord model changes
+    #
+    # @param [ActiveRecord::Base] model Model to watch for changes
+    # @param [Hash] options Streaming options
+    #
+    def stream_notifications_for(model, options = {})
+      # Default options
+      options = {
+      }.merge(options)
+
+      # These options cannot be overridden
+      options[:model] = model
+      options[:channel] = self
+      options[:broadcasting] = model.model_name.collection
+
+      # Sets channel options
+      self.ActionCableNotifications[options[:broadcasting]] = options
+
+      # Checks if model already includes notification callbacks
+      if !model.respond_to? :ActionCableNotificationsOptions
+        model.send('include', ActionCableNotifications::Model)
+      end
+
+      # Sets broadcast options if they are not already present in the model
+      if not model.ActionCableNotificationsOptions.key? options[:broadcasting]
+        model.broadcast_notifications_from options[:broadcasting], options
+      end
+
+      # Start streaming
+      stream_from options[:broadcasting], coder: ActiveSupport::JSON do |packet|
+        transmit_packet(packet)
+      end
+
+    end
+
+    #
+    # Transmits packets to connected client
+    #
+    # @param [Hash] packet Packet with changes notifications
+    #
+    def transmit_packet(packet)
+      packet = packet.as_json.deep_symbolize_keys!
+      if update_cache(packet)
+        transmit packet
+      end
+    end
+
+    #
+    # Updates server side cache of client side collections
+    # XXX compute cache diff before sending to clients
+    #
+    def update_cache(packet)
+      updated = false
+
+      # Check if collection already exists
+      new_collection = false
+      if @collections[packet[:collection]].nil?
+        @collections[packet[:collection]] = []
+        new_collection = true
+      end
+
+      collection = @collections[packet[:collection]]
+
+      case packet[:msg]
+      when 'upsert_many'
+        if new_collection
+          packet[:data].each do |record|
+            collection.push record
+          end
+          updated = true
+        else
+          packet[:data].each do |record|
+            current_record = collection.find{|c| c[:id]==record[:id]}
+            if current_record
+              new_record = current_record.merge(record)
+              if new_record != current_record
+                current_record.merge!(record)
+                updated = true
+              end
+            else
+              collection.push record
+              updated = true
+            end
+          end
+        end
+
+      when 'create'
+        record = collection.find{|c| c[:id]==packet[:id]}
+        if !record
+          @collections[packet[:collection]].push packet[:data]
+          updated = true
+        end
+
+      when 'update'
+        record = @collections[packet[:collection]].find{|c| c[:id]==packet[:id]}
+        if record
+          record.merge!(packet[:data])
+          updated = true
+        end
+
+      when 'destroy'
+        index = @collections[packet[:collection]].find_index{|c| c.id==packet[:id]}
+        if index
+          @collections[packet[:collection]].delete_at(index)
+          updated = true
+        end
+
+      else
+        updated = true
+      end
+
+      updated
+
+    end
+
+  end
+end

data/lib/action_cable_notifications/channel_actions.rb

@@ -0,0 +1,144 @@
+module ActionCableNotifications
+  module Channel
+    module Actions
+      #
+      # Fetch records from the DB and send them to the client
+      #
+      # @param [Hash] selector Specifies conditions that the registers should match
+      #
+      def fetch(data)
+        # XXX: Check if the client is allowed to call the method
+
+        params = data[:params] || {}
+
+        # Get results using provided parameters and model configured scope
+        results = data[:model].
+                    select(params[:select]).
+                    limit(params[:limit]).
+                    where(params[:where] || {}).
+                    scoped_collection(data[:model_options][:scope]).
+                    to_a() rescue []
+
+        response = { collection: data[:model].model_name.collection,
+          msg: 'upsert_many',
+          data: results
+        }
+
+        # Send data to the client
+        transmit_packet response
+      end
+
+      #
+      # Creates one record in the DB
+      #
+      def create(data)
+        # XXX: Check if the client is allowed to call the method
+
+        params = data[:params] || {}
+        fields = params[:fields].except(:id)
+
+        error = nil
+
+        if fields.present?
+          begin
+            record = data[:model].create(fields)
+
+            if !record.persisted?
+              error = true
+            end
+          rescue Exception => e
+            error = e.message
+          end
+        else
+          error = "No fields were provided"
+        end
+
+        if error
+          response = {
+            collection: data[:model].model_name.collection,
+            msg: 'error',
+            cmd: 'create',
+            error: error || record.errors.full_messages
+          }
+
+          # Send error notification to the client
+          transmit response
+        end
+
+      end
+
+
+      #
+      # Update one record from the DB
+      #
+      def update(data)
+        # XXX: Check if the client is allowed to call the method
+
+        params = data[:params] || {}
+
+        record = data[:model].find(params[:id]) rescue nil
+
+        error = nil
+
+        if record.present?
+          begin
+            record.update_attributes(params[:fields])
+          rescue Exception => e
+            error = e.message
+          end
+        else
+          error = "There is no record with id: #{params[:id]}"
+        end
+
+        if error
+          response = {
+            collection: data[:model].model_name.collection,
+            msg: 'error',
+            cmd: 'update',
+            error: error || record.errors.full_messages
+          }
+
+          # Send error notification to the client
+          transmit response
+        end
+
+      end
+
+      #
+      # Remove records from the DB
+      #
+      def destroy(data)
+        # XXX: Check if the client is allowed to call the method
+
+        params = data[:params] || {}
+
+        record = data[:model].find(params[:id]) rescue nil
+
+        error = nil
+
+        if record.present?
+          begin
+            record.destroy
+          rescue Exception => e
+            error = e.message
+          end
+        else
+          error = "There is no record with id: #{params[:id]}"
+        end
+
+        if error
+          response = { collection: data[:model].model_name.collection,
+            msg: 'error',
+            cmd: 'destroy',
+            error: error || record.errors.full_messages
+          }
+
+          # Send error notification to the client
+          transmit response
+        end
+
+      end
+
+    end
+  end
+end

data/lib/action_cable_notifications/engine.rb

@@ -1,6 +1,6 @@
 require 'lodash-rails'
-require 'action_cable_notifications/callbacks.rb'
-require 'action_cable_notifications/streams.rb'
+require 'action_cable_notifications/model.rb'
+require 'action_cable_notifications/channel.rb'
 
 module ActionCableNotifications
   class Engine < ::Rails::Engine

data/lib/action_cable_notifications/{callbacks.rb → model.rb}

@@ -1,5 +1,5 @@
 module ActionCableNotifications
-  module Callbacks
+  module Model
     extend ActiveSupport::Concern
 
     included do
@@ -10,7 +10,7 @@ module ActionCableNotifications
       # Register Callbacks
       after_update :notify_update
       after_create :notify_create
-      before_destroy :notify_destroy
+      after_destroy :notify_destroy
     end
 
     module ClassMethods
@@ -40,7 +40,8 @@ module ActionCableNotifications
       # @return [ActiveRecordRelation] Results fetched from the database
       #
       def scoped_collection ( scope = :all )
-        Array(scope).inject(self) {|o, a| o.try(*a)}
+        scope = scope.to_a if scope.is_a? Hash
+        Array(scope).inject(self) {|o, a| o.try(*a)} rescue nil
       end
 
       #
@@ -59,7 +60,7 @@ module ActionCableNotifications
         if options.present?
           {
             collection: self.model_name.collection,
-            msg: 'update_many',
+            msg: 'upsert_many',
             data: self.scoped_collection(options[:scope])
           }
         end
@@ -94,21 +95,23 @@ module ActionCableNotifications
         changes[k] = v[1]
       end
 
-      self.ActionCableNotificationsOptions.each do |broadcasting, options|
-        if options[:actions].include? :update
-          # Checks if record is within scope before broadcasting
-          if self.class.scoped_collection(options[:scope]).where(id: self.id)
-            # XXX: Performance required. For small data sets this should be
-            # fast enough, but for large data sets this could be slow. As
-            # clients should have a limited subset of the dataset loaded at a
-            # time, caching the results already sent to clients in server memory
-            # should not have a big impact in memory usage but can improve
-            # performance for large data sets where only a sub
-            ActionCable.server.broadcast broadcasting,
-              collection: self.model_name.collection,
-              msg: 'update',
-              id: self.id,
-              data: changes
+      if !changes.empty?
+        self.ActionCableNotificationsOptions.each do |broadcasting, options|
+          if options[:actions].include? :update
+            # Checks if record is within scope before broadcasting
+            if self.class.scoped_collection(options[:scope]).where(id: self.id)
+              # XXX: Performance required. For small data sets this should be
+              # fast enough, but for large data sets this could be slow. As
+              # clients should have a limited subset of the dataset loaded at a
+              # time, caching the results already sent to clients in server memory
+              # should not have a big impact in memory usage but can improve
+              # performance for large data sets where only a sub
+              ActionCable.server.broadcast broadcasting,
+                collection: self.model_name.collection,
+                msg: 'update',
+                id: self.id,
+                data: changes
+            end
           end
         end
       end

data/lib/action_cable_notifications/version.rb

@@ -1,3 +1,3 @@
 module ActionCableNotifications
-  VERSION = '0.1.14'
+  VERSION = '0.1.18'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: action_cable_notifications
 version: !ruby/object:Gem::Version
-  version: 0.1.14
+  version: 0.1.18
 platform: ruby
 authors:
 - ByS Sistemas de Control
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-09-29 00:00:00.000000000 Z
+date: 2016-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -58,6 +58,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Rails engine that provides Automatic realtime notification broadcast
   for ActiveRecord models changes using Action Cable and websockets
 email:
@@ -76,6 +104,7 @@ files:
 - app/assets/javascripts/action_cable_notifications/collection.coffee
 - app/assets/javascripts/action_cable_notifications/default_callbacks.coffee
 - app/assets/javascripts/action_cable_notifications/store.coffee
+- app/assets/javascripts/action_cable_notifications/tracker.js
 - app/assets/stylesheets/action_cable_notifications/application.css
 - app/controllers/action_cable_notifications/application_controller.rb
 - app/helpers/action_cable_notifications/application_helper.rb
@@ -85,9 +114,10 @@ files:
 - app/views/layouts/action_cable_notifications/application.html.erb
 - config/routes.rb
 - lib/action_cable_notifications.rb
-- lib/action_cable_notifications/callbacks.rb
+- lib/action_cable_notifications/channel.rb
+- lib/action_cable_notifications/channel_actions.rb
 - lib/action_cable_notifications/engine.rb
-- lib/action_cable_notifications/streams.rb
+- lib/action_cable_notifications/model.rb
 - lib/action_cable_notifications/version.rb
 - lib/tasks/action_cable_notifications_tasks.rake
 homepage: https://github.com/bys-control/action_cable_notifications