activity_notification 1.7.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f16ad8322faabd5fec778b470437863df703dcf1
-  data.tar.gz: 87eb45c1c03c92836aa5a72b7b1e07cf2fb8548b
+SHA256:
+  metadata.gz: 2a31c915030fbad2174abd43cd1e64656cbc609e7fdd2521b06bccdfa46ea69e
+  data.tar.gz: 4d24557f5a670b094be8d5bb5ab8c07763d7944c7fb1de550c5f4dc956d50906
 SHA512:
-  metadata.gz: 8a34fa413bd90c2fb8228115bc7f76f12ddb0ca8c7d981f761b10692ec3aa1bd4239781bdd3001c33aa5ed4497e4b7f842d05a77fe3e86ccddaa347df9e8d05f
-  data.tar.gz: ae29b5111bbef97182cd0fdbeab616c332a53779e19cb940afe2300e7672591a7ebb490044b006f97447cdb662371aff46311b7274eefd0ab9923476a7414c87
+  metadata.gz: 156543325a87e170ebe74d1a2dbc2bcf8c9870bb69c86ef8689f5634a564ed84f286c6965baf79ac84b8bd82dbbdd7bceb522faeeef09e028cfdc038c3284008
+  data.tar.gz: a911a86c566b7d3c7bbeeacbc78f9db7ca9dfff4f2496544d4c3190076cfd742ead7902e077af3cffb041532557c19f3ab3fd687f9ccf79fca9f951ff957c337

data/.gitignore

@@ -10,6 +10,8 @@
 /spec/examples.txt
 /spec/rails_app/log/*
 /spec/rails_app/tmp/*
+/spec/rails_app/public/assets/
+/spec/DynamoDBLocal-latest/
 /test/tmp/
 /test/version_tmp/
 /tmp/
@@ -17,6 +19,7 @@
 *~
 *.sqlite3
 .project
+.DS_Store
 
 # Used by dotenv library to load environment variables.
 # .env

data/.travis.yml

@@ -15,14 +15,20 @@ gemfile:
   - gemfiles/Gemfile.rails-5.0
   - gemfiles/Gemfile.rails-5.1
   - gemfiles/Gemfile.rails-5.2
+  - gemfiles/Gemfile.rails-6.0.rc
 
 env:
   - AN_ORM=active_record
   - AN_ORM=active_record AN_TEST_DB=mysql
   - AN_ORM=active_record AN_TEST_DB=postgresql
+  - AN_ORM=mongoid
   - AN_ORM=mongoid AN_TEST_DB=mongodb
+  - AN_ORM=dynamoid
 
 matrix:
+  exclude:
+    - gemfile: gemfiles/Gemfile.rails-4.2
+      env: AN_ORM=dynamoid
   include:
     - rvm: ruby-head
       gemfile: Gemfile
@@ -30,11 +36,16 @@ matrix:
     - rvm: ruby-head
       gemfile: Gemfile
       env: AN_ORM=mongoid
+    - rvm: ruby-head
+      gemfile: Gemfile
+      env: AN_ORM=dynamoid
   allow_failures:
     - rvm: ruby-head
   fast_finish: true
 
 services:
+  - mysql
+  - postgresql
   - mongodb
 
 sudo: false
@@ -48,12 +59,15 @@ before_install:
 install:
   # Specify bundler version as '< 2.0' for Rails 4.2
   - bundle _1.17.3_ install
+  - if [ "$AN_ORM" = "dynamoid" ]; then bin/install_dynamodblocal.sh; fi
 
 before_script:
   # Specify bundler version as '< 2.0' for Rails 4.2
   - bundle _1.17.3_ update
-  - mysql -e 'create database activity_notification_test'
-  - psql -c 'create database activity_notification_test' -U postgres
+  - if [ "$AN_TEST_DB" = "mysql" ]; then mysql -e 'create database activity_notification_test'; fi
+  - if [ "$AN_TEST_DB" = "postgresql" ]; then psql -c 'create database activity_notification_test' -U postgres; fi
+  - if [ "$AN_ORM" = "dynamoid" ]; then bin/start_dynamodblocal.sh; fi
+  - if [ "$AN_ORM" = "dynamoid" ]; then export AWS_DEFAULT_REGION=ap-northeast-1 AWS_ACCESS_KEY_ID=dummy AWS_SECRET_ACCESS_KEY=dummy; fi
 
 script: bundle exec rspec
 

data/CHANGELOG.md

@@ -1,4 +1,24 @@
-## 1.7.0 / 2019-04-30
+## 2.0.0 / 2019-08-09
+[Full Changelog](http://github.com/simukappu/activity_notification/compare/v1.7.1...v2.0.0)
+
+Enhancements:
+
+* Add push notification with Action Cable - [#101](https://github.com/simukappu/activity_notification/issues/101)
+* Allow use with Rails 6.0 - [#102](https://github.com/simukappu/activity_notification/issues/102)
+* Add Amazon DynamoDB support using Dynamoid
+* Add *ActivityNotification.config.store_with_associated_records* option
+* Add test case using Mongoid orm with ActiveRecord application
+* Publish demo application on Heroku
+
+Bug Fixes:
+
+* Fix syntax error of a default view *_default_without_grouping.html.erb*
+
+Deprecated:
+
+* Remove deprecated *ActivityNotification.config.table_name* option
+
+## 1.7.1 / 2019-04-30
 [Full Changelog](http://github.com/simukappu/activity_notification/compare/v1.7.0...v1.7.1)
 
 Enhancements:
@@ -184,7 +204,7 @@ Bug Fixes:
 
 Breaking Changes:
 
-* Remove *notifiable_type* from the argument of overriden method or configured lambda function with *:batch_email_allowed* option in *acts_as_target* role
+* Remove *notifiable_type* from the argument of overridden method or configured lambda function with *:batch_email_allowed* option in *acts_as_target* role
 
 ## 1.0.2 / 2016-11-14
 [Full Changelog](http://github.com/simukappu/activity_notification/compare/v1.0.1...v1.0.2)

data/Gemfile

@@ -4,12 +4,19 @@ gemspec
 
 gem 'rails', '~> 5.2'
 
+group :production do
+  gem 'puma'
+  gem 'pg'
+  gem 'devise'
+end
+
 group :development do
   gem 'bullet'
 end
 
 group :test do
   gem 'rails-controller-testing'
+  gem 'action-cable-testing'
   gem 'ammeter'
   gem 'timecop'
   gem 'coveralls', require: false

data/Procfile

@@ -0,0 +1,2 @@
+web: cd spec/rails_app; bin/rails server Puma -p $PORT -e $RAILS_ENV; cd -
+console: cd spec/rails_app; bin/rails console -e $RAILS_ENV; cd -

data/README.md

@@ -8,25 +8,42 @@
 [![Gem Downloads](https://img.shields.io/gem/dt/activity_notification.svg)](https://rubygems.org/gems/activity_notification)
 [![MIT License](http://img.shields.io/badge/license-MIT-blue.svg?style=flat)](MIT-LICENSE)
 
-*activity_notification* provides integrated user activity notifications for Ruby on Rails. You can easily use it to configure multiple notification targets and make activity notifications with notifiable models, like adding comments, responding etc.
+*activity_notification* provides integrated user activity notifications for [Ruby on Rails](https://rubyonrails.org). You can easily use it to configure multiple notification targets and make activity notifications with notifiable models, like adding comments, responding etc.
 
-*activity_notification* supports Rails 4.2+ with ActiveRecord and [Mongoid](http://mongoid.org) ORM. It is tested for MySQL, PostgreSQL, SQLite3 with ActiveRecord and MongoDB with Mongoid.
+*activity_notification* supports Rails 4.2+ with [ActiveRecord](https://guides.rubyonrails.org/active_record_basics.html), [Mongoid](https://mongoid.org) and [Dynamoid](https://github.com/Dynamoid/dynamoid) ORM. It is tested for [MySQL](https://www.mysql.com), [PostgreSQL](https://www.postgresql.org), [SQLite3](https://www.sqlite.org) with ActiveRecord, [MongoDB](https://www.mongodb.com) with Mongoid and [Amazon DynamoDB](https://aws.amazon.com/dynamodb) with Dynamoid. The latest *activity_notification* [v2](https://rubygems.org/gems/activity_notification) is almost compatible with [v1](https://rubygems.org/gems/activity_notification/versions/1.7.1).
 
 
 ## About
 
 *activity_notification* provides following functions:
 * Notification API (creating notifications, query for notifications and managing notification parameters)
-* Notification models (stored with ActiveRecord or Mongoid ORM)
+* Notification models (stored with ActiveRecord, Mongoid or Dynamoid ORM)
 * Notification controllers (managing open/unopen of notifications, providing link to notifiable activity page)
 * Notification views (presentation of notifications)
 * Automatic tracked notifications (generating notifications along with the lifecycle of notifiable models)
 * Grouping notifications (grouping like *"Kevin and 7 other users posted comments to this article"*)
 * Email notification
 * Batch email notification (event driven or periodical email notification, daily or weekly etc)
+* Push notification with [Action Cable](https://guides.rubyonrails.org/action_cable_overview.html)
 * Subscription management (subscribing and unsubscribing for each target and notification type)
 * Integration with [Devise](https://github.com/plataformatec/devise) authentication
-* Optional notification targets (Configurable optional notification targets like Amazon SNS, Slack, SMS and so on)
+* Activity notifications stream integrated into cloud computing using [Amazon DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html)
+* Optional notification targets (Configurable optional notification targets like [Amazon SNS](https://aws.amazon.com/sns), [Slack](https://slack.com), SMS and so on)
+
+### Online demo
+
+You can see an actual application using this gem here: **https://activity-notification-example.herokuapp.com/**
+
+Login as the following test users to experience user activity notifications:
+
+| Email | Password | Admin? |
+|:---:|:---:|:---:|
+| ichiro@example.com  | changeit | Yes |
+| stephen@example.com | changeit |     |
+| klay@example.com    | changeit |     |
+| kevin@example.com   | changeit |     |
+
+The deployed demo application is included in this gem's source code as a test application here: **[/spec/rails_app](/spec/rails_app/)**
 
 ### Notification index and plugin notifications
 <kbd>![plugin-notifications-image](https://raw.githubusercontent.com/simukappu/activity_notification/images/activity_notification_plugin_focus_with_subscription.png)</kbd>
@@ -51,6 +68,8 @@
   - [Database setup](#database-setup)
     - [Using ActiveRecord ORM](#using-activerecord-orm)
     - [Using Mongoid ORM](#using-mongoid-orm)
+    - [Using Dynamoid ORM](#using-dynamoid-orm)
+      - [Integration with DynamoDB Streams](#integration-with-dynamodb-streams)
   - [Configuring models](#configuring-models)
     - [Configuring target models](#configuring-target-models)
     - [Configuring notifiable models](#configuring-notifiable-models)
@@ -87,9 +106,13 @@
     - [Managing subscriptions](#managing-subscriptions)
     - [Customizing subscriptions](#customizing-subscriptions)
   - [Integration with Devise](#integration-with-devise)
-    - [Configuring integration with Devise](#configuring-integration-with-devise)
+    - [Configuring integration with Devise authentication](#configuring-integration-with-devise-authentication)
     - [Using different model as target](#using-different-model-as-target)
     - [Configuring simple default routes](#configuring-simple-default-routes)
+  - [Push notification with Action Cable](#push-notification-with-action-cable)
+    - [Enabling broadcasting notifications to channels](#enabling-broadcasting-notifications-to-channels)
+    - [Subscribing notifications from channels](#subscribing-notifications-from-channels)
+    - [Subscribing notifications with Devise authentication](#subscribing-notifications-with-devise-authentication)
   - [Optional notification targets](#optional-notification-targets)
     - [Configuring optional targets](#configuring-optional-targets)
     - [Customizing message format](#customizing-message-format)
@@ -154,7 +177,6 @@ The same can be done for the subscription table name, e.g., if you're using the
 config.subscription_table_name = "notifications_subscriptions"
 ```
 
-
 #### Using Mongoid ORM
 
 When you use *activity_notification* with [Mongoid](http://mongoid.org) ORM, set **AN_ORM** environment variable to **mongoid**:
@@ -171,6 +193,124 @@ config.orm = :mongoid
 
 You need to configure Mongoid in your Rails application for your MongoDB environment. Then, your notifications and subscriptions will be stored in your MongoDB.
 
+#### Using Dynamoid ORM
+
+When you use *activity_notification* with [Dynamoid](https://github.com/Dynamoid/dynamoid) ORM, set **AN_ORM** environment variable to **dynamoid**:
+
+```console
+$ export AN_ORM=dynamoid
+```
+
+You can also configure ORM in initializer **activity_notification.rb**:
+
+```ruby
+config.orm = :dynamoid
+```
+
+You need to configure Dynamoid in your Rails application for your Amazon DynamoDB environment.
+Then, you can use this rake task to create DynamoDB tables used by *activity_notification* with Dynamoid:
+
+```console
+$ bin/rake activity_notification:create_dynamodb_tables
+```
+
+After these configurations, your notifications and subscriptions will be stored in your Amazon DynamoDB.
+
+Note: Amazon DynamoDB integration using Dynamoid ORM is only supported with Rails 5.0+.
+
+##### Integration with DynamoDB Streams
+
+You can capture *activity_notification*'s table activity with [DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html).
+Using DynamoDB Streams, activity notifications in your Rails application will be integrated into cloud computing and available as event stream processed by [DynamoDB Streams Kinesis Adapter](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.KCLAdapter.html) or [AWS Lambda](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.Lambda.html).
+
+When you consume your activity notifications from DynamoDB Streams, sometimes you need to process notification records with associated target, notifiable or notifier record which is stored in database of your Rails application.
+In such cases, you can use **store_with_associated_records** option in initializer **activity_notification.rb**:
+
+```ruby
+config.store_with_associated_records = true
+```
+
+When **store_with_associated_records** is set to *false* as default, *activity_notification* stores notificaion records with association like this:
+
+```json
+{
+    "id": {
+        "S": "f05756ef-661e-4ef5-9e99-5af51243125c"
+    },
+    "target_key": {
+        "S": "User#1"
+    },
+    "notifiable_key": {
+        "S": "Comment#2"
+    },
+    "key": {
+        "S": "comment.default"
+    },
+    "group_key": {
+        "S": "Article#1"
+    },
+    "notifier_key": {
+        "S": "User#2"
+    },
+    "created_at": {
+        "N": "1560085332.689929"
+    },
+    "updated_at": {
+        "N": "1560085332.695515"
+    },
+    "parameters": {
+        "M": {}
+    }
+}
+```
+
+When you set **store_with_associated_records** to *true*, *activity_notification* stores notificaion records including associated target, notifiable and notifier like this:
+
+```json
+{
+    "id": {
+        "S": "f05756ef-661e-4ef5-9e99-5af51243125c"
+    },
+    "target_key": {
+        "S": "User#1"
+    },
+    "target_record": {
+        "S": "{\"id\":1,\"email\":\"ichiro@example.com\",\"name\":\"Ichiro\",\"created_at\":\"2019-06-09T13:10:44.853Z\",\"updated_at\":\"2019-06-09T13:10:44.853Z\"}"
+    },
+    "notifiable_key": {
+        "S": "Comment#2"
+    },
+    "notifiable_record": {
+        "S": "{\"id\":2,\"user_id\":2,\"article_id\":1,\"body\":\"This is the first Stephen's comment to Ichiro's article.\",\"created_at\":\"2019-06-09T13:10:45.677Z\",\"updated_at\":\"2019-06-09T13:10:45.677Z\"}"
+    },
+    "key": {
+        "S": "comment.default"
+    },
+    "group_key": {
+        "S": "Article#1"
+    },
+    "notifier_key": {
+        "S": "User#2"
+    },
+    "notifier_record": {
+        "S": "{\"id\":2,\"email\":\"stephen@example.com\",\"name\":\"Stephen\",\"created_at\":\"2019-06-09T13:10:45.006Z\",\"updated_at\":\"2019-06-09T13:10:45.006Z\"}"
+    },
+    "created_at": {
+        "N": "1560085332.689929"
+    },
+    "updated_at": {
+        "N": "1560085332.695515"
+    },
+    "parameters": {
+        "M": {}
+    }
+}
+```
+
+Then, you can process notification records with associated records in your DynamoDB Streams.
+
+Note: This **store_with_associated_records** option can be set true only when you use mongoid or dynamoid ORM.
+
 ### Configuring models
 
 #### Configuring target models
@@ -325,7 +465,7 @@ Rails.application.routes.draw do
 end
 ```
 
-Then, you can access several pages like */users/1/notifications* and manage open/unopen of notifications using **notifications_controller**.
+Then, you can access several pages like */users/1/notifications* and manage open/unopen of notifications using *[ActivityNotification::NotificationsController](/app/controllers/activity_notification/notifications_controller.rb)*.
 If you use Devise integration and you want to configure simple default routes for authenticated users, see [Configuring simple default routes](#configuring-simple-default-routes).
 
 #### Routes with scope
@@ -571,6 +711,8 @@ notification:
       destroy:
         text: 'Some user removed an article!'
     comment:
+      create:
+        text: '%{notifier_name} posted a comment on the article "%{article_title}"'
       post:
         text:
           one: "<p>%{notifier_name} posted a comment on your article %{article_title}</p>"
@@ -656,13 +798,13 @@ Set up SMTP server configuration for *ActionMailer*. Then, you need to set up th
 config.action_mailer.default_url_options = { host: 'localhost', port: 3000 }
 ```
 
-Email notification is disabled as default. You can configure to enable email notification in initializer *activity_notification.rb*.
+Email notification is disabled as default. You can configure it to enable email notification in initializer *activity_notification.rb*.
 
 ```ruby
 config.email_enabled = true
 ```
 
-You can also configure them for each model by *acts_as roles* like these.
+You can also configure them for each model by *acts_as roles* like these:
 
 ```ruby
 class User < ActiveRecord::Base
@@ -709,7 +851,7 @@ config.mailer_sender = ->(key){ key == 'inquiry.post' ? 'support@example.com' :
 
 #### Email templates
 
-*activity_notification* will look for email template in the same way as notification views. For example, if you have a notification with *:key* set to *"notification.comment.reply"* and target_type *users*, the gem will look for a partial in *app/views/activity_notification/mailer/users/comment/_reply.html.(|erb|haml|slim|something_else)*.
+*activity_notification* will look for email template in a similar way as notification views, but the view file name is not start with an underscore. For example, if you have a notification with *:key* set to *"notification.comment.reply"* and target_type *users*, the gem will look for a partial in *app/views/activity_notification/mailer/users/comment/reply.html.(|erb|haml|slim|something_else)*.
 
 If this template is missing, the gem will look for a partial in *default* as the target type which means *activity_notification/mailer/default/_default.html.(|erb|haml|slim|something_else)*.
 
@@ -762,7 +904,7 @@ notification:
 
 Set up SMTP server configuration for *ActionMailer* and the default URL options for the *activity_notification* mailer in each environment.
 
-Batch email notification is disabled as default. You can configure to enable email notification in initializer *activity_notification.rb* like single email notification.
+Batch email notification is disabled as default. You can configure it to enable email notification in initializer *activity_notification.rb* like single email notification.
 
 ```ruby
 config.email_enabled = true
@@ -885,13 +1027,13 @@ Then, you will see *"Kevin and 7 other users posted 10 comments to your article"
 
 #### Configuring subscriptions
 
-Subscription management is disabled as default. You can configure to enable subscription management in initializer *activity_notification.rb*.
+Subscription management is disabled as default. You can configure it to enable subscription management in initializer *activity_notification.rb*.
 
 ```ruby
 config.subscription_enabled = true
 ```
 
-This makes all target model subscribers. You can also configure them for each target model by *acts_as_target* role like this.
+This makes all target model subscribers. You can also configure them for each target model by *acts_as_target* role like this:
 
 ```ruby
 class User < ActiveRecord::Base
@@ -978,7 +1120,7 @@ Rails.application.routes.draw do
 end
 ```
 
-Then, you can access *users/1/subscriptions* and use **subscriptions_controller** or **subscriptions_with_devise_controller** to manage the subscriptions.
+Then, you can access *users/1/subscriptions* and use *[ActivityNotification::SubscriptionsController](/app/controllers/activity_notification/subscriptions_controller.rb)* or *[ActivityNotification::SubscriptionsWithDeviseController](/app/controllers/activity_notification/subscriptions_with_devise_controller.rb)* to manage the subscriptions.
 
 If you would like to customize subscription controllers or views, you can use generators like notifications:
 
@@ -1007,7 +1149,7 @@ If you would like to customize subscription controllers or views, you can use ge
 
 *activity_notification* supports to integrate with devise authentication.
 
-#### Configuring integration with Devise
+#### Configuring integration with Devise authentication
 
 Add **:with_devise** option in notification routing to *config/routes.rb* for the target:
 
@@ -1019,7 +1161,7 @@ Rails.application.routes.draw do
 end
 ```
 
-Then *activity_notification* will use **notifications_with_devise_controller** as a notification controller. The controller actions automatically call *authenticate_user!* and the user will be restricted to access and operate own notifications only, not others'.
+Then *activity_notification* will use *[ActivityNotification::NotificationsWithDeviseController](/app/controllers/activity_notification/notifications_with_devise_controller.rb)* as a notification controller. The controller actions automatically call *authenticate_user!* and the user will be restricted to access and operate own notifications only, not others'.
 
 *Hint*: HTTP 403 Forbidden will be returned for unauthorized notifications.
 
@@ -1073,6 +1215,156 @@ end
 Then, you can access */admins/notifications* instead of */admins/1/notifications*.
 
 
+### Push notification with Action Cable
+
+*activity_notification* supports push notification with Action Cable by WebSocket.
+*activity_notification* only provides Action Cable channels implementation, does not connections.
+You can use default implementaion in Rails or your custom `ApplicationCable::Connection` for Action Cable connections.
+
+#### Enabling broadcasting notifications to channels
+
+Broadcasting notifications to Action Cable channels is disabled as default. You can configure it to enable Action Cable broadcasting in initializer *activity_notification.rb*.
+
+```ruby
+config.action_cable_enabled = true
+```
+
+You can also configure them for each model by *acts_as roles* like these:
+
+```ruby
+class User < ActiveRecord::Base
+  # Allow Action Cable broadcasting
+  acts_as_target action_cable_allowed: true
+end
+```
+
+```ruby
+class Comment < ActiveRecord::Base
+  belongs_to :article
+  belongs_to :user
+
+  acts_as_notifiable :users,
+    targets: ->(comment, key) {
+      ([comment.article.user] + comment.article.commented_users.to_a - [comment.user]).uniq
+    },
+    # Allow Action Cable broadcasting
+    action_cable_allowed: true
+end
+```
+
+Then, *activity_notification* will broadcast configured notidications to target channels by *[ActivityNotification::NotificationApi](/lib/activity_notification/apis/notification_api.rb)#broadcast_to_action_cable_channel* method.
+
+#### Subscribing notifications from channels
+
+*activity_notification* provides *[ActivityNotification::NotificationChannel](/app/channels/activity_notification/notification_channel.rb)* to subscribe broadcasted notifications with Action Cable.
+
+You can simply create subscriptions for the specified target in your view like this:
+
+```js
+<script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/push.js/1.0.9/push.min.js"></script>
+<script>
+  App.activity_notification = App.cable.subscriptions.create(
+    {
+      channel: "ActivityNotification::NotificationChannel",
+      target_type: "<%= @target.to_class_name %>", target_id: "<%= @target.id %>"
+    },
+    {
+      connected: function() {
+        // Connected
+      },
+      disconnected: function() {
+        // Disconnected
+      },
+      rejected: function() {
+        // Rejected
+      },
+      received: function(notification) {
+        // Display notification
+
+        // Push notificaion using Web Notification API by Push.js
+        Push.create('ActivityNotification', {
+            body: notification.text,
+            timeout: 5000,
+            onClick: function () {
+                location.href = notification.notifiable_path;
+                this.close();
+            }
+        });
+      }
+    }
+  );
+</script>
+```
+
+Then, *activity_notification* will push desktop notification using Web Notification API.
+
+#### Subscribing notifications with Devise authentication
+
+To use Devise integration, enable subscribing notifications with Devise authentication in initializer *activity_notification.rb*.
+
+```ruby
+config.action_cable_with_devise = true
+```
+
+You can also configure them for each target model by *acts_as_target* like this:
+
+```ruby
+class User < ActiveRecord::Base
+  # Allow Action Cable broadcasting and enable subscribing notifications with Devise authentication
+  acts_as_target action_cable_allowed: true, action_cable_with_devise: true
+end
+```
+
+When you set *action_cable_with_devise* option to *true*, `ActivityNotification::NotificationChannel` will reject your subscription requests for the target type.
+
+*activity_notification* also provides *[ActivityNotification::NotificationWithDeviseChannel](/app/channels/activity_notification/notification_with_devise_channel.rb)* to create subscriptions integrated with Devise authentication.
+You can simply use `ActivityNotification::NotificationWithDeviseChannel` instead of `ActivityNotification::NotificationChannel`:
+
+```js
+App.activity_notification = App.cable.subscriptions.create(
+  {
+    channel: "ActivityNotification::NotificationWithDeviseChannel",
+    target_type: "<%= @target.to_class_name %>", target_id: "<%= @target.id %>"
+  },
+  {
+    // ...
+  }
+);
+```
+
+You can also create these subscriptions with *devise_type* parameter instead of *target_id* parameter like this:
+
+```js
+App.activity_notification = App.cable.subscriptions.create(
+  {
+    channel: "ActivityNotification::NotificationWithDeviseChannel",
+    target_type: "users", devise_type: "users"
+  },
+  {
+    // ...
+  }
+);
+```
+
+`ActivityNotification::NotificationWithDeviseChannel` will confirm subscription requests from authenticated cookies by Devise. If the user has not signed in, the subscription request will be rejected. If the user has signed in as unauthorized user, the subscription request will be also rejected.
+
+In addtion, you can use `Target#notification_action_cable_channel_class_name` method to select channel class depending on your *action_cable_with_devise* configuration for the target.
+
+```js
+App.activity_notification = App.cable.subscriptions.create(
+  {
+    channel: "<%= @target.notification_action_cable_channel_class_name %>",
+    target_type: "<%= @target.to_class_name %>", target_id: "<%= @target.id %>"
+  },
+  {
+    // ...
+  }
+);
+```
+
+This script is also implemented in [default notifications index view](/app/views/activity_notification/notifications/default/index.html.erb) of *activity_notification*.
+
+
 ### Optional notification targets
 
 *activity_notification* supports configurable optional notification targets like Amazon SNS, Slack, SMS and so on.
@@ -1080,7 +1372,7 @@ Then, you can access */admins/notifications* instead of */admins/1/notifications
 #### Configuring optional targets
 
 *activity_notification* provides default optional target implementation for Amazon SNS and Slack.
-You can develop any optional target classes which extends *ActivityNotification::OptionalTarget::Base*, and configure them to notifiable model by *acts_as_notifiable* like this.
+You can develop any optional target classes which extends *ActivityNotification::OptionalTarget::Base*, and configure them to notifiable model by *acts_as_notifiable* like this:
 
 ```ruby
 class Comment < ActiveRecord::Base
@@ -1216,7 +1508,7 @@ module CustomOptionalTarget
 end
 ```
 
-Then, you can configure them to notifiable model by *acts_as_notifiable* like this.
+Then, you can configure them to notifiable model by *acts_as_notifiable* like this:
 
 ```ruby
 class Comment < ActiveRecord::Base
@@ -1301,38 +1593,77 @@ $ bundle exec rspec
 $ bundle exec rake
 ```
 
-#### Dummy Rails application
-Test module includes dummy Rails application in **spec/rails_app**. You can run the dummy application as common Rails application.
+##### Testing with DynamoDB Local
+You can use [DynamoDB Local](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/DynamoDBLocal.html) to test Amazon DynamoDB integration in your local environment.
+
+At first, set up DynamoDB Local by install script:
+```console
+$ bin/install_dynamodblocal.sh
+```
+Then, start DynamoDB Local by start script:
+```console
+$ bin/start_dynamodblocal.sh
+```
+And you can stop DynamoDB Local by stop script:
+```console
+$ bin/stop_dynamodblocal.sh
+```
+
+In short, you can test DynamoDB integration by the following step:
+```console
+$ git pull https://github.com/simukappu/activity_notification.git
+$ cd activity_notification
+$ bundle install —path vendor/bundle
+$ bin/install_dynamodblocal.sh
+$ bin/start_dynamodblocal.sh
+$ AN_ORM=dynamoid bundle exec rspec
+```
+
+#### Example Rails application
+Test module includes example Rails application in **[spec/rails_app](/spec/rails_app)**. You can run the example application as common Rails application.
 ```console
 $ cd spec/rails_app
 $ bin/rake db:migrate
 $ bin/rake db:seed
 $ bin/rails server
 ```
-Then, you can access <http://localhost:3000> for the dummy application.
+Then, you can access <http://localhost:3000> for the example application.
 
 ##### Run with your local database
-As default, dummy Rails application runs with local SQLite database in *spec/rails_app/db/development.sqlite3*.
-This application supports to run with your local MySQL, PostgreSQL and MongoDB.
-Set **AN_TEST_DB** environment variable like:
+As default, example Rails application runs with local SQLite database in *spec/rails_app/db/development.sqlite3*.
+This application supports to run with your local MySQL, PostgreSQL, MongoDB.
+Set **AN_TEST_DB** environment variable as follows.
+
+To use MySQL:
 ```console
 $ export AN_TEST_DB=mysql
 ```
-for MySQL,
+To use PostgreSQL:
 ```console
 $ export AN_TEST_DB=postgresql
 ```
-for PostgreSQL, and
+To use MongoDB:
 ```console
 $ export AN_TEST_DB=mongodb
 ```
-for MongoDB. When you set **mongodb** as *AN_TEST_DB*, you have to use *activity_notification* with MongoDB. Also set **AN_ORM** like:
+When you set **mongodb** as *AN_TEST_DB*, you have to use *activity_notification* with MongoDB. Also set **AN_ORM** like:
 ```console
 $ export AN_ORM=mongoid
 ```
 
-Then, configure *spec/rails_app/config/database.yml* or *spec/rails_app/config/mongoid.yml* as your local database.
-Finally, run database migration, seed data script and the dummy appliation.
+You can also run this Rails application in cross database environment like these:
+
+To use MySQL for your application and use MongoDB for *activity_notification*:
+```console
+$ export AN_ORM=mongoid AN_TEST_DB=mysql
+```
+To use PostgreSQL for your application and use Amazon DynamoDB for *activity_notification*:
+```console
+$ export AN_ORM=dynamoid AN_TEST_DB=postgresql
+```
+
+Then, configure *spec/rails_app/config/database.yml* or *spec/rails_app/config/mongoid.yml*, *spec/rails_app/config/dynamoid.rb* as your local database.
+Finally, run database migration, seed data script and the example appliation.
 ```console
 $ cd spec/rails_app
 $ # You don't need migration when you use MongoDB only (AN_ORM=mongoid and AN_TEST_DB=mongodb)
@@ -1357,14 +1688,18 @@ $ bundle exec yard server
 ```
 Then you can see the documents at <http://localhost:8808/docs/index>.
 
+
 ## Common examples
 
-To be prepared. See dummy Rails application in *spec/rails_app*.
+See example Rails application in **[/spec/rails_app](/spec/rails_app)**.
+
+You can also try this example Rails application as a online demo here: **https://activity-notification-example.herokuapp.com/**  
+You can login as test users to experience user activity notifications. For more details, see [Online demo](#online-demo).
 
 
 ## Help
 
-We are welcome your Github issues for gem problems or enhancement requests. If you have any questions or problems for your own application environment, contact us by email of this repository.
+We are welcome your Github issues for gem problems or enhancement requests.
 
 
 ## Contributing
@@ -1372,7 +1707,6 @@ We are welcome your Github issues for gem problems or enhancement requests. If y
 We are welcome all of your pull requests! Please check out the followings:
 * Write tests with RSpec
 * Write code docs and README if necessary
-* Send your pull request to *development* branch (Do NOT send to *master* branch)
 
 
 ## License