onesignal-rails-plugin 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 54e86f1ddbe283916a63b125cce2b1c305524bda45ff3b6ca7b8055cf3ac8c34
+  data.tar.gz: a85a401454cdef5db2a480311d15be0e89498f8488ac4c4c06ae8e2cfc85e75b
+SHA512:
+  metadata.gz: 11807aa7f347a12863029745f76b654c34798d0fc7cf2dd0a67f856c1fe773eea125c36ec07ff9709396e319d5fa23b29fc3654ca8da9171beaaab7ad4439ef2
+  data.tar.gz: a2c65de51c44706e60a38f07efd194883a289d4b90d1e45c5452334591ddfc52ce3a55f92967ab3a45ec38da18696d3fadc41aded0db11534d94dcd3c374573a

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in onesignal-rails-plugin.gemspec
+gemspec
+
+group :development, :test do
+  gem 'pry'
+  gem 'rake', '~> 13.0.1'
+  gem 'rubocop', '~> 1.29'
+  gem 'standard'
+end

data/Gemfile.lock

@@ -0,0 +1,215 @@
+PATH
+  remote: .
+  specs:
+    onesignal-rails-plugin (1.0.0)
+      onesignal (~> 1.0.1)
+      rails
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actioncable (7.0.3)
+      actionpack (= 7.0.3)
+      activesupport (= 7.0.3)
+      nio4r (~> 2.0)
+      websocket-driver (>= 0.6.1)
+    actionmailbox (7.0.3)
+      actionpack (= 7.0.3)
+      activejob (= 7.0.3)
+      activerecord (= 7.0.3)
+      activestorage (= 7.0.3)
+      activesupport (= 7.0.3)
+      mail (>= 2.7.1)
+      net-imap
+      net-pop
+      net-smtp
+    actionmailer (7.0.3)
+      actionpack (= 7.0.3)
+      actionview (= 7.0.3)
+      activejob (= 7.0.3)
+      activesupport (= 7.0.3)
+      mail (~> 2.5, >= 2.5.4)
+      net-imap
+      net-pop
+      net-smtp
+      rails-dom-testing (~> 2.0)
+    actionpack (7.0.3)
+      actionview (= 7.0.3)
+      activesupport (= 7.0.3)
+      rack (~> 2.0, >= 2.2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.2.0)
+    actiontext (7.0.3)
+      actionpack (= 7.0.3)
+      activerecord (= 7.0.3)
+      activestorage (= 7.0.3)
+      activesupport (= 7.0.3)
+      globalid (>= 0.6.0)
+      nokogiri (>= 1.8.5)
+    actionview (7.0.3)
+      activesupport (= 7.0.3)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.1, >= 1.2.0)
+    activejob (7.0.3)
+      activesupport (= 7.0.3)
+      globalid (>= 0.3.6)
+    activemodel (7.0.3)
+      activesupport (= 7.0.3)
+    activerecord (7.0.3)
+      activemodel (= 7.0.3)
+      activesupport (= 7.0.3)
+    activestorage (7.0.3)
+      actionpack (= 7.0.3)
+      activejob (= 7.0.3)
+      activerecord (= 7.0.3)
+      activesupport (= 7.0.3)
+      marcel (~> 1.0)
+      mini_mime (>= 1.1.0)
+    activesupport (7.0.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    ast (2.4.2)
+    builder (3.2.4)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.10)
+    crass (1.0.6)
+    diff-lcs (1.5.0)
+    digest (3.1.0)
+    erubi (1.10.0)
+    ethon (0.15.0)
+      ffi (>= 1.15.0)
+    ffi (1.15.5)
+    globalid (1.0.0)
+      activesupport (>= 5.0)
+    i18n (1.10.0)
+      concurrent-ruby (~> 1.0)
+    loofah (2.18.0)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    mail (2.7.1)
+      mini_mime (>= 0.1.1)
+    marcel (1.0.2)
+    method_source (1.0.0)
+    mini_mime (1.1.2)
+    minitest (5.15.0)
+    net-imap (0.2.3)
+      digest
+      net-protocol
+      strscan
+    net-pop (0.1.1)
+      digest
+      net-protocol
+      timeout
+    net-protocol (0.1.3)
+      timeout
+    net-smtp (0.3.1)
+      digest
+      net-protocol
+      timeout
+    nio4r (2.5.8)
+    nokogiri (1.13.6-x86_64-darwin)
+      racc (~> 1.4)
+    onesignal (1.0.1)
+      typhoeus (~> 1.0, >= 1.0.1)
+    parallel (1.22.1)
+    parser (3.1.2.0)
+      ast (~> 2.4.1)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    racc (1.6.0)
+    rack (2.2.3.1)
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rails (7.0.3)
+      actioncable (= 7.0.3)
+      actionmailbox (= 7.0.3)
+      actionmailer (= 7.0.3)
+      actionpack (= 7.0.3)
+      actiontext (= 7.0.3)
+      actionview (= 7.0.3)
+      activejob (= 7.0.3)
+      activemodel (= 7.0.3)
+      activerecord (= 7.0.3)
+      activestorage (= 7.0.3)
+      activesupport (= 7.0.3)
+      bundler (>= 1.15.0)
+      railties (= 7.0.3)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.4.2)
+      loofah (~> 2.3)
+    railties (7.0.3)
+      actionpack (= 7.0.3)
+      activesupport (= 7.0.3)
+      method_source
+      rake (>= 12.2)
+      thor (~> 1.0)
+      zeitwerk (~> 2.5)
+    rainbow (3.1.1)
+    rake (13.0.6)
+    regexp_parser (2.4.0)
+    rexml (3.2.5)
+    rspec (3.11.0)
+      rspec-core (~> 3.11.0)
+      rspec-expectations (~> 3.11.0)
+      rspec-mocks (~> 3.11.0)
+    rspec-core (3.11.0)
+      rspec-support (~> 3.11.0)
+    rspec-expectations (3.11.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-mocks (3.11.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.11.0)
+    rspec-support (3.11.0)
+    rubocop (1.29.1)
+      parallel (~> 1.10)
+      parser (>= 3.1.0.0)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.17.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 3.0)
+    rubocop-ast (1.18.0)
+      parser (>= 3.1.1.0)
+    rubocop-performance (1.13.3)
+      rubocop (>= 1.7.0, < 2.0)
+      rubocop-ast (>= 0.4.0)
+    ruby-progressbar (1.11.0)
+    standard (1.12.1)
+      rubocop (= 1.29.1)
+      rubocop-performance (= 1.13.3)
+    strscan (3.0.3)
+    thor (1.2.1)
+    timeout (0.3.0)
+    typhoeus (1.4.0)
+      ethon (>= 0.9.0)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    unicode-display_width (2.1.0)
+    websocket-driver (0.7.5)
+      websocket-extensions (>= 0.1.0)
+    websocket-extensions (0.1.5)
+    zeitwerk (2.5.4)
+
+PLATFORMS
+  x86_64-darwin-21
+
+DEPENDENCIES
+  onesignal-rails-plugin!
+  pry
+  rake (~> 13.0.1)
+  rspec
+  rubocop (~> 1.29)
+  standard
+
+BUNDLED WITH
+   2.2.3

data/LICENSE

@@ -0,0 +1,24 @@
+Modified MIT License
+
+Copyright 2021 OneSignal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+1. The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+2. All copies of substantial portions of the Software may only be used in connection
+with services provided by OneSignal.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,239 @@
+<h1 align="center">Welcome to the official OneSignal Ruby on Rails Plugin 👋</h1>
+
+[![Gem Version][rgb]][rgl]
+
+<p>
+  <a href="https://github.com/OneSignal/onesignal-rails-plugin/blob/master/README.md" target="_blank">
+    <img alt="Documentation" src="https://img.shields.io/badge/documentation-yes-brightgreen.svg" />
+  </a>
+  <a href="https://github.com/OneSignal/onesignal-rails-plugin/graphs/commit-activity" target="_blank">
+    <img alt="Maintenance" src="https://img.shields.io/badge/Maintained%3F-yes-green.svg" />
+  </a>
+  <a href="https://twitter.com/onesignal" target="_blank">
+    <img alt="Twitter: onesignal" src="https://img.shields.io/twitter/follow/onesignal.svg?style=social" />
+  </a>
+</p>
+
+OneSignal - the Ruby on Rails gem for OneSignal
+
+A powerful way to send personalized messages at scale and build effective customer engagement strategies. Learn more at onesignal.com
+
+This gem provides OneSignal integration via the Ruby on Rails ActionMailer. A custom delivery method `:onesignal` can be used to direct
+your Action Mailers to send emails through the OneSignal API.  Additional extensions to the mail functionality are provided to take
+advantage of OneSignal's customer engagement platform! 
+
+### 🖤 [RubyGems](https://rubygems.org/gems/onesignal-rails-plugin)
+
+## 🚧 In Beta 🚧
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'onesignal-rails-plugin', '~> 1.0.0.beta1'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install onesignal-rails-plugin -pre
+
+Or install from Github:
+
+    $ gem "onesignal-rails-plugin", '~> 1.0.0.beta1', git: 'git://github.com/OneSignal/onesignal-rails-plugin.git'
+
+
+## Configuration
+
+To change all action mailers to target the OneSignal integration, edit `config/application.app` or `config/environments/$ENVIRONMENT.rb` and 
+add/change the following to the ActionMailer configuration
+
+```ruby
+config.action_mailer.delivery_method = :onesignal
+```
+
+Alternatively a specific ActionMailer can be configured to use the OneSignal delivery method.  Within your ActionMailer
+
+```ruby
+class MyOneSignalActionMailer < ActionMailer::Base
+  self.delivery_method = :onesignal  
+
+  def some_email(params)
+    mail(...)
+  end
+end
+```
+
+The OneSignal-specific configuration information can be set in either environment variables or more dynamically via code. To access your app ID
+and REST API key, please view the [documentation](https://documentation.onesignal.com/docs/accounts-and-keys).
+
+Choose one of the following ways to provide your OneSignal-specific configuration:
+1. [Using Environment Variables](#Using-Environment-Variables)
+2. [Using Application Configuration](#Using-Application-Configuration)
+3. [Using ActionMailer Configuration](#Using-ActionMailer-Configuration)
+
+### Using Environment Variables
+Ensure the OneSignal environment variables have been set, the `OneSignal::Rails::Plugin` module will pick these up automatically
+```
+ONESIGNAL_APP_KEY = 'your-app-key'
+ONESIGNAL_APP_ID = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
+```
+
+### Using Application Configuration
+The `OneSignal::Rails::Plugin` module can be configured in code by creating initializer file `config/initializers/onesignal_rails_plugin.rb` and adding the following
+(Warning: for security purposes, REST API keys should not be hardcoded into your application)
+
+```ruby
+OneSignal::Rails::Plugin.configure do |c|
+  c.app_key = 'your-app-key'
+  c.app_id = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
+end
+```
+
+### Using ActionMailer Configuration
+For more granular and dynamic control, you can also configure as part of the ActionMailer configuration.  Edit `config/application.app` or
+`config/environments/$ENVIRONMENT.rb` and add the following to the ActionMailer configuration (Warning: for security purposes, REST API keys should not
+be hardcoded into your application)
+
+```ruby
+config.action_mailer.onesignal_settings = {
+      app_key = 'your-app-key',
+      app_id = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
+    }
+```
+
+Similar to how the `delivery_method` is configured, alternatively a specific ActionMailer can be configured to have a more granular configuration.  Within your
+ActionMailer add the following (Warning: for security purposes, REST API keys should not be hardcoded into your application)
+
+```ruby
+class MyOneSignalActionMailer < ActionMailer::Base
+  self.delivery_method = :onesignal
+  self.onesignal_settings = {
+      app_key = 'your-app-key',
+      app_id = 'XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX'
+    }
+
+  def some_email(params)
+    mail(...)
+  end
+end
+```
+
+## Usage
+If the purpose of the ActionMailer is to generate a transactional email where the recipient, subject, and body are specified within the application,
+no additional changes are required. Your existing ActionMailers will now send emails through your OneSignal integration!
+
+## OneSignal Extensions
+The mail functionality is extended to include additional attributes provided by the OneSignal API.  These attributes should be specified within your
+ActionMailer through the `mail` invocation.  See [Examples](#Examples) for examples of how to invoke `mail` to exploit these extensions.
+
+### template_id (string)
+Specifies the id of a template created within OneSignal that should be used, rather than the body provided by your application (either via the `body`
+parameter, or defined within the view of the ActionMailer). To use the subject within the template, specify a `OneSignal::Rails::Plugin::USE_TEMPLATE_SUBJECT` within
+the `subject` parameter.  If the `subject` parameter is set to anything else, it will be used as the subject of the email, overriding the subject within the template. 
+
+### include_external_user_ids (string array)
+A string array that lists the OneSignal external IDs that are to be the recipients of the email being sent, rather than the information provided by your application via the `to` parameter.
+
+### include_player_ids (string array)
+A string array that lists the OneSignal player IDs that are to be the recipients of the email being sent, rather than the information provided by your application via the `to` parameter.
+
+### included_segments (string array)
+A string array that lists the OneSignal segments that are to be the recipients of the email being sent, rather than the information provided by your application via the `to` parameter.
+
+### excluded_segments (string array)
+A string array that lists the OneSignal segments that will not be the recipients of the email being sent (all others will), rather than the information provided by your application via the `to` parameter.
+
+### custom_notification_args (object)
+An object that allows for customizing the email notification that will be sent.  Each property key and value of the object will be copied into the payload of the create notification operation.
+This allows for greater customization of notification being sent.  Example of parameters that would most likely be specified within this object:
+- *external_id:* Correlation and idempotency key.
+- *send_after:* Schedule the message for future delivery.
+- *throttle_rate_per_minute:* throttle delivery of the notification, either because throttling is not enabled at the application level or to override the application level throttling settings.
+
+Note the following are not currently supported by the Ruby API library.
+- *name:* identifier for tracking this message within the OneSignal dashboard or export analytics, not shown to the end user.
+- *disable_email_click_tracking:* When true the URLs in the email will not change to link tracking URLs and will stay the same as originally set. Best used for emails containing Universal Links.  Defaults to false.
+
+Note the following are not currently supported by the API backend.
+- *delayed_option:* Can be `timezone` or `last-active`.
+- *delivery_time_of_day:* when delayed_option=timezone, this is the time of day to deliver within the timezone.
+
+## Examples
+
+The following shows examples of how to invoke the `mail` function within your ActionMailer when integrated with OneSignal. Note the body is not specified as it is assumed to be generated through the view associated
+to the ActionMailer.  This is not an exhaustive list, and different examples could be combined depending on your specific scenario.
+
+```ruby
+# Send a transactional email to a specific recipient (standard ActionMailer usage) 
+mail(subject: "email example", from: 'no-reply@company.com', to: 'user@company.co')
+
+# Send a transactional email, relying on the OneSignal default 'from' address specified within the OneSignal dashboard
+mail(subject: "use OneSignal default from address example", to: 'user@company.co')
+
+# Send an email using a OneSignal template as both the subject and body of the email
+mail(subject: OneSignal::Rails::Plugin::USE_TEMPLATE_SUBJECT, to: 'user@company.co', template_id: '00000000-0000-0000-0000-000000000000')
+
+# Send an email using a OneSignal template, overriding the subject specified on the template
+mail(subject: "template subject override example", to: 'user@company.co', template_id: '00000000-0000-0000-0000-000000000000')
+
+# Send an email to a list of OneSignal users via their external user IDs
+mail(subject: "external id example", include_external_user_ids: ["User123", "User456"])
+
+# Send an email to a list of OneSignal users via their player IDs
+mail(subject: "player id example", include_player_ids: ["00000000-0000-0000-0000-000000000000", "11111111-1111-1111-1111-111111111111"])
+
+# Send an email to a list of OneSignal users that are within the provided segments
+mail(subject: "include segments example", included_segments: ["Subscribed Users"])
+
+# Send an email to the app's audience, excluding the provided segments.
+mail(subject: "excluded segments example", excluded_segments: ["Engaged Users"])
+
+# Send an email with the external_id, which ensures idempotency
+mail(subject: "set external_id example", to: 'user@company.co', custom_notification_args: { 'external_id' => "00000000-0000-0000-0000-000000000000" })
+
+# Send an email after a certain time
+mail(subject: "send after example", to: 'user@company.co', custom_notification_args: { 'send_after' => "2022-05-19 15:20:00 GMT-0400" })
+
+# Send an email with rate throttling
+mail(subject: "throttle rate example", to: 'user@company.co', custom_notification_args: { 'throttle_rate_per_minute' => 1 })
+```
+
+## Testing
+
+To run the rspec tests
+
+    $ bundle exec rspec --format documentation
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License][mit].
+
+[rgb]: https://img.shields.io/gem/v/onesignal-rails-plugin.svg
+[rgl]: https://rubygems.org/gems/onesignal-rails-plugin
+[osa]: https://documentation.onesignal.com/reference/
+[mit]: http://opensource.org/licenses/MIT
+
+## Author
+
+* Website: https://onesignal.com
+* Twitter: [@onesignal](https://twitter.com/onesignal)
+* Github: [@OneSignal](https://github.com/OneSignal)
+
+## 🤝 Contributing
+
+Contributions, issues and feature requests are welcome!<br />Feel free to check [issues page](https://github.com/OneSignal/onesignal-rail-plugin/issues).
+
+## Show your support
+
+Give a ⭐️ if this project helped you!
+
+## 📝 License
+
+Copyright © 2022 [OneSignal](https://github.com/OneSignal).<br />
+This project is [MIT](https://opensource.org/licenses/MIT) licensed.

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+
+begin
+  require 'rspec/core/rake_task'
+
+  RSpec::Core::RakeTask.new(:spec)
+  task default: :spec
+rescue LoadError
+  # no rspec available
+end

data/lib/onesignal/rails/plugin/delivery_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module OneSignal
+  module Rails
+    module Plugin
+      ##
+      # Provides a custom exception for when OneSignal is unable to deliver a mail.
+      class DeliveryError < StandardError
+        # The response from the OneSignal API, if a response exists.
+        attr_reader :response
+
+        def initialize(msg = 'OneSignal Delivery Error', response = nil)
+          @response = response
+          super(msg)
+        end
+      end
+    end
+  end
+end

data/lib/onesignal/rails/plugin/delivery_method.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'onesignal'
+
+module OneSignal
+  module Rails
+    module Plugin
+      ##
+      # Provides the ActionMailer delivery method of :onesignal.  When this delivery method is used,
+      # mail sent by an ActionMailer is sent to OneSignal through an email notification.  Alternatively
+      # or in addition to the standard mail funcitonality, additional OneSignal specific parameters
+      # can be specified to take advantage of OneSignal specific functionality.
+      class DeliveryMethod
+        DEFAULTS = {
+          perform_send_request: true,
+          return_response: false,
+          app_key: nil,
+          app_id: nil
+        }.freeze
+
+        attr_accessor :settings
+
+        def initialize(settings = {})
+          self.settings = DEFAULTS.merge(settings)
+        end
+
+        def deliver!(mail)
+          validate(mail)
+
+          notification = OneSignal::Notification.new({ app_id: settings[:app_id] || OneSignal::Rails::Plugin.configuration.app_id,
+                                                      is_ios: false })
+
+          add_from(notification, mail)
+          add_to(notification, mail)
+          add_subject(notification, mail)
+          add_body(notification, mail)
+          add_custom_notification_args(notification, mail)
+
+          response = if settings[:perform_send_request] == false
+                      notification
+                    else
+                      send notification
+                    end
+
+          settings[:return_response] ? response : self
+        end
+
+        private
+
+        def validate(mail)
+          # subject cannot be USE_TEMPLATE_SUBJECT unless template_id is specified (templates provide the subject)
+          if (mail.subject == USE_TEMPLATE_SUBJECT) && !mail['template_id']
+            raise 'Must specify template_id if setting subject to OneSignal::Rails::Plugin::USE_TEMPLATE_SUBJECT!'
+          end
+        end
+
+        def add_from(notification, mail)
+          from_email = first_email(mail.from)
+
+          notification.email_from_address = from_email.address if from_email&.address
+          notification.email_from_name = from_email.display_name || from_email.name if from_email&.address
+        end
+
+        def add_to(notification, mail)
+          # a specified "to override" takes priority over any "to" provided within the mail input
+          if does_override_to(mail)
+            if mail['include_external_user_ids']
+              notification.include_external_user_ids = mail['include_external_user_ids'].value.split(',').map(&:strip)
+              notification.channel_for_external_user_ids = 'email'
+            end
+            if mail['include_player_ids']
+              notification.include_player_ids = mail['include_player_ids'].value.split(',').map(&:strip)
+            end
+            if mail['included_segments']
+              notification.included_segments = mail['included_segments'].value.split(',').map(&:strip)
+            end
+            if mail['excluded_segments']
+              notification.excluded_segments = mail['excluded_segments'].value.split(',').map(&:strip)
+            end
+          else
+            notification.include_email_tokens = mail.to
+          end
+        end
+
+        def does_override_to(mail)
+          mail['include_external_user_ids'] ||
+            mail['include_player_ids'] ||
+            mail['included_segments'] ||
+            mail['excluded_segments']
+        end
+
+        def add_subject(notification, mail)
+          notification.email_subject = mail.subject if mail.subject != USE_TEMPLATE_SUBJECT
+        end
+
+        def add_body(notification, mail)
+          # a specified template takes priority over any body provided within the mail
+          if mail['template_id']
+            notification.template_id = mail['template_id'].value
+          else
+            case mail.mime_type
+            when 'text/plain', 'text/html'
+              notification.email_body = mail.body.decoded
+            when 'multipart/alternative', 'multipart/mixed', 'multipart/related'
+              # for multipart, the html will always win if it exists
+              notification.email_body = mail.text_part.decoded if mail.text_part
+              notification.email_body = mail.html_part.decoded if mail.html_part
+            end
+          end
+        end
+
+        def add_custom_notification_args(notification, mail)
+          input = mail['custom_notification_args']
+          if input.is_a?(Mail::Field)
+            input.unparsed_value.each do |key, value|
+              notification.send("#{key}=", value)
+            end
+          elsif input.respond_to?('each')
+            input.each do |item|
+              item.unparsed_value.each do |key, value|
+                notification.send("#{key}=", value)
+              end
+            end
+          elsif input
+            raise DeliveryError, "Unknown type for customer_notification_args: #{input.class.name}"
+          end
+        end
+
+        def first_email(input)
+          convert_emails(input).first
+        end
+
+        def convert_emails(input)
+          if input.is_a?(String)
+            [Mail::Address.new(input)]
+          elsif input.is_a?(::Mail::AddressContainer) && !input.instance_variable_get('@field').nil?
+            input.instance_variable_get('@field').addrs.map # Already Mail::Address
+          elsif input.is_a?(::Mail::AddressContainer)
+            input.map do |addr|
+              Mail::Address.new(addr)
+            end
+          elsif input.is_a?(::Mail::StructuredField)
+            [Mail::Address.new(input.value)]
+          elsif input.nil?
+            []
+          else
+            raise OneSignalDeliveryError, "Unknown type for email: #{input.class.name}"
+          end
+        end
+
+        def client
+          # we create our own configuration in case the OneSignal library is used outside of the
+          # ActionMailer context, with different options
+          config = OneSignal::Configuration.new
+          config.configure do |c|
+            c.app_key = settings[:app_key] || OneSignal::Rails::Plugin.configuration.app_key
+          end
+
+          OneSignal::DefaultApi.new(OneSignal::ApiClient.new(config))
+        end
+
+        def send(notification)
+          response = client.create_notification(notification)
+
+          raise DeliveryError.new('OneSignal request responded with errors', response) if response.errors
+        end
+      end
+    end
+  end
+end

data/lib/onesignal/rails/plugin/literals.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module OneSignal
+  module Rails
+    module Plugin
+      USE_TEMPLATE_SUBJECT = 'USE_TEMPLATE_SUBJECT'
+    end
+  end
+end

data/lib/onesignal/rails/plugin/railtie.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module OneSignal
+  module Rails
+    module Plugin
+      ##
+      # The One Signal Rails Extension class
+      class Railtie < ::Rails::Railtie
+        # Add the :onesignal delivery method to the ActionMailer framework
+        initializer 'onesignal_rails_plugin.add_delivery_method', before: 'action_mailer.set_configs' do
+          ActiveSupport.on_load(:action_mailer) do
+            ActionMailer::Base.add_delivery_method(:onesignal, OneSignal::Rails::Plugin::DeliveryMethod)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/onesignal/rails/plugin/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module OneSignal
+  module Rails
+    module Plugin
+      VERSION = '1.0.0'
+    end
+  end
+end

data/lib/onesignal/rails/plugin.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'onesignal/rails/plugin/delivery_method'
+require 'onesignal/rails/plugin/delivery_error'
+require 'onesignal/rails/plugin/literals'
+require 'onesignal/rails/plugin/railtie'
+require 'onesignal/rails/plugin/version'
+
+##
+# This module contains all classes provided by the OneSignal Rails plugin.
+module OneSignal
+  module Rails
+    class << self
+      # This is required because other gems in the OneSignal module namespace
+      # specifically use `Rails.logger` thinking they are picking up the
+      # Rails logger. So we proxy that for them.
+      def logger
+        ::Rails.logger
+      end
+    end
+
+    module Plugin
+      class << self
+        attr_writer :configuration
+      end
+
+      def self.configuration
+        @configuration ||= Configuration.new
+      end
+
+      def self.configure
+        self.configuration ||= Configuration.new
+        yield(configuration)
+      end
+
+      ##
+      # Configuration options for the OneSignal plugin.
+      class Configuration
+        attr_accessor :app_key, :app_id
+
+        def initialize
+          set_defaults
+        end
+
+        def set_defaults
+          @app_key = if ENV.key?('ONESIGNAL_APP_KEY')
+                      ENV['ONESIGNAL_APP_KEY']
+                    else
+                      ''
+                    end
+
+          @app_id = if ENV.key?('ONESIGNAL_APP_ID')
+                      ENV['ONESIGNAL_APP_ID']
+                    else
+                      ''
+                    end
+        end
+      end
+    end
+  end
+end

data/onesignal-rails-plugin.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+# #OneSignal
+#
+# A powerful way to send personalized messages at scale and build effective customer
+# engagement strategies. Learn more at onesignal.com.
+#
+# Contact: devrel@onesignal.com
+#
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+require 'onesignal/rails/plugin/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'onesignal-rails-plugin'
+  s.version     = OneSignal::Rails::Plugin::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['OneSignal']
+  s.email       = ['devrel@onesignal.com']
+  s.homepage    = 'https://onesignal.com/'
+  s.summary     = 'OneSignal for Rails'
+  s.description = 'A custom Rails ActionMailer delivery method which will send emails through your OneSignal integration'
+  s.license     = 'Modified MIT'
+  s.required_ruby_version = '>= 2.5'
+
+  s.add_dependency 'onesignal', '~> 1.0.1'
+  s.add_dependency 'rails'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+
+  s.files         = `find *`.split("\n").uniq.sort.reject(&:empty?)
+  s.test_files    = `find spec/*`.split("\n")
+  s.executables   = []
+  s.require_paths = ['lib']
+end

data/spec/lib/onesignal/rails/plugin/delivery_method_spec.rb

@@ -0,0 +1,308 @@
+# frozen_string_literal: true
+
+require_relative '../../../../spec_helper'
+require 'mail'
+
+module OneSignal
+  module Rails
+    module Plugin
+      EMAIL_TEXT_BODY = 'I am a plain text body'
+      EMAIL_HTML_BODY = 'I am an <b>HTML</b> body'
+      ALT_APP_ID = '11111111-1111-1111-1111-111111111111'
+      ALT_APP_KEY = 'ALT_APP_KEY'
+
+      describe 'DeliveryMethod' do
+        subject(:mailer) do
+          DeliveryMethod.new(perform_send_request: false, return_response: true)
+        end
+
+        describe 'initializing' do
+          it 'defaults return_response to false' do
+            m = DeliveryMethod.new
+            expect(m.settings[:return_response]).to eq(false)
+          end
+
+          it 'defaults perform_send_request to true' do
+            m = DeliveryMethod.new
+            expect(m.settings[:perform_send_request]).to eq(true)
+          end
+
+          it 'defaults app_id to nil' do
+            m = DeliveryMethod.new
+            expect(m.settings[:app_id]).to be_nil
+          end
+
+          it 'defaults app_key to nil' do
+            m = DeliveryMethod.new
+            expect(m.settings[:app_key]).to be_nil
+          end
+
+          it 'allows setting of return_response to true' do
+            m = DeliveryMethod.new(return_response: true)
+            expect(m.settings[:return_response]).to eq(true)
+          end
+
+          it 'allows setting of app_id to a value' do
+            m = DeliveryMethod.new(app_id: ALT_APP_ID)
+            expect(m.settings[:app_id]).to eq(ALT_APP_ID)
+          end
+
+          it 'allows setting of app_key to a value' do
+            m = DeliveryMethod.new(app_key: ALT_APP_KEY)
+            expect(m.settings[:app_key]).to eq(ALT_APP_KEY)
+          end
+        end
+
+        describe '#deliver!' do
+          let(:mail) do
+            Mail.new(
+              to: 'test@example.com',
+              from: 'test@company.co',
+              subject: 'Hello Test!'
+            )
+          end
+
+          context 'when using initialization' do
+            it 'returns mailer itself' do
+              m = DeliveryMethod.new(perform_send_request: false)
+              ret = m.deliver!(mail)
+              expect(ret).to eq(m)
+            end
+
+            it 'captures app id in notification from configuration' do
+              notification = mailer.deliver!(mail)
+              expect(notification.app_id).to eq(APP_ID)
+            end
+
+            it 'uses app id from configuration when set' do
+              m = DeliveryMethod.new(app_id: ALT_APP_ID, perform_send_request: false, return_response: true)
+              notification = m.deliver!(mail)
+              expect(notification.app_id).to eq(ALT_APP_ID)
+            end
+          end
+
+          context 'when sending email to' do
+            it 'supports single email address' do
+              notification = mailer.deliver!(mail)
+              expect(notification.include_email_tokens).to eq ['test@example.com']
+            end
+            it 'supports single email address with name' do
+              mail.to = 'Test Person <test@example.com>'
+              notification = mailer.deliver!(mail)
+              expect(notification.include_email_tokens).to eq ['test@example.com']
+            end
+            it 'supports single email address with quoted name' do
+              mail.to = '"Test Person" <test@example.com>'
+              notification = mailer.deliver!(mail)
+              expect(notification.include_email_tokens).to eq ['test@example.com']
+            end
+            it 'supports multiple email addresses' do
+              mail.to = 'test1@example.com;test2@example.com'
+              notification = mailer.deliver!(mail)
+              expect(notification.include_email_tokens).to eq ['test1@example.com', 'test2@example.com']
+            end
+            it 'supports multiple email addresses with names' do
+              mail.to = 'Test1 Person <test1@example.com>; Test2 Person <test2@example.com>'
+              notification = mailer.deliver!(mail)
+              expect(notification.include_email_tokens).to eq ['test1@example.com', 'test2@example.com']
+            end
+            it 'supports multiple email addresses with quoted names' do
+              mail.to = '"Test1 Person" <test1@example.com>; "Test2 Person" <test2@example.com>'
+              notification = mailer.deliver!(mail)
+              expect(notification.include_email_tokens).to eq ['test1@example.com', 'test2@example.com']
+            end
+          end
+
+          context 'when sending email from' do
+            it 'supports not setting from' do
+              mail.from = nil
+              notification = mailer.deliver!(mail)
+              expect(notification.email_from_address).to be_nil
+              expect(notification.email_from_name).to be_nil
+            end
+
+            it 'supports email address' do
+              notification = mailer.deliver!(mail)
+              expect(notification.email_from_address).to eq('test@company.co')
+              expect(notification.email_from_name).to be_nil
+            end
+
+            it 'supports email address with name' do
+              mail.from = 'Test Person <test@company.co>'
+              notification = mailer.deliver!(mail)
+              expect(notification.email_from_address).to eq('test@company.co')
+              expect(notification.email_from_name).to eq('Test Person')
+            end
+
+            it 'supports email address with quoted name' do
+              mail.from = '"Test Person" <test@company.co>'
+              notification = mailer.deliver!(mail)
+              expect(notification.email_from_address).to eq('test@company.co')
+              expect(notification.email_from_name).to eq('Test Person')
+            end
+
+            it 'ignores all but first email address' do
+              mail.from = 'test1@company.co;test2@company.co'
+              notification = mailer.deliver!(mail)
+              expect(notification.email_from_address).to eq('test1@company.co')
+            end
+          end
+
+          context 'when sending email subject' do
+            it 'supports subject' do
+              notification = mailer.deliver!(mail)
+              expect(notification.email_subject).to eq('Hello Test!')
+            end
+
+            it 'fails if told not to provide subject but no template is used' do
+              mail.subject = OneSignal::Rails::Plugin::USE_TEMPLATE_SUBJECT
+              expect do
+                mailer.deliver!(mail)
+              end.to raise_exception('Must specify template_id if setting subject to OneSignal::Rails::Plugin::USE_TEMPLATE_SUBJECT!')
+            end
+          end
+
+          context 'when sending email body' do
+            it 'supports body with text/plain content' do
+              mail.content_type = 'text/plain'
+              mail.body = EMAIL_TEXT_BODY
+              notification = mailer.deliver!(mail)
+              expect(notification.email_body).to eq(EMAIL_TEXT_BODY)
+            end
+
+            it 'supports body with text/html content' do
+              mail.content_type = 'text/html'
+              mail.body = EMAIL_HTML_BODY
+              notification = mailer.deliver!(mail)
+              expect(notification.email_body).to eq(EMAIL_HTML_BODY)
+            end
+
+            it 'chooses text/html body with both text/html and text/plain content' do
+              mail.content_type = 'multipart/mixed'
+              mail.part do |p|
+                p.html_part = Mail::Part.new do
+                  content_type 'text/html'
+                  body EMAIL_HTML_BODY
+                end
+                p.text_part = Mail::Part.new do
+                  content_type 'text/plain'
+                  body EMAIL_TEXT_BODY
+                end
+              end
+
+              notification = mailer.deliver!(mail)
+              expect(notification.email_body).to eq(EMAIL_HTML_BODY)
+            end
+          end
+
+          context 'when sending email template' do
+            before do
+              mail['template_id'] = '1'
+            end
+
+            it 'sets template_id with value' do
+              notification = mailer.deliver!(mail)
+              expect(notification.template_id).to eq('1')
+            end
+
+            it 'sets subject if specified' do
+              notification = mailer.deliver!(mail)
+              expect(notification.email_subject).to eq('Hello Test!')
+            end
+
+            it 'ignores subject when told to not use it' do
+              mail.subject = OneSignal::Rails::Plugin::USE_TEMPLATE_SUBJECT
+              notification = mailer.deliver!(mail)
+              expect(notification.email_subject).to be_nil
+            end
+
+            it 'ignores body if specified' do
+              mail.content_type = 'text/plain'
+              mail.body = EMAIL_TEXT_BODY
+              notification = mailer.deliver!(mail)
+              expect(notification.email_body).to be_nil
+            end
+          end
+
+          context 'when sending email to existing OneSignal users via extensions' do
+            it 'supports include_external_user_ids' do
+              mail['include_external_user_ids'] = %w[1 2 3]
+              notification = mailer.deliver!(mail)
+              expect(notification.include_external_user_ids).to eq(%w[1 2 3])
+              expect(notification.channel_for_external_user_ids).to eq('email')
+              expect(notification.include_email_tokens).to be_nil
+            end
+
+            it 'supports include_player_ids' do
+              mail['include_player_ids'] = %w[1 2 3]
+              notification = mailer.deliver!(mail)
+              expect(notification.include_player_ids).to eq(%w[1 2 3])
+              expect(notification.include_email_tokens).to be_nil
+            end
+
+            it 'supports included_segments' do
+              mail['included_segments'] = %w[1 2 3]
+              notification = mailer.deliver!(mail)
+              expect(notification.included_segments).to eq(%w[1 2 3])
+              expect(notification.include_email_tokens).to be_nil
+            end
+
+            it 'supports excluded_segments' do
+              mail['excluded_segments'] = %w[1 2 3]
+              notification = mailer.deliver!(mail)
+              expect(notification.excluded_segments).to eq(%w[1 2 3])
+              expect(notification.include_email_tokens).to be_nil
+            end
+          end
+
+          context 'when sending email with custom_notification_args extensions' do
+            # TODO: These properties exist in the API, but not in the Ruby client yet
+            # it 'supports name' do
+            #   mail['custom_notification_args'] = {'name' => 'Test'}
+            #   notification = mailer.deliver!(mail)
+            #   expect(notification.name).to eq("Test")
+            # end
+            # it 'supports disable_email_click_tracking' do
+            #   mail['custom_notification_args'] = {'disable_email_click_tracking' => true}
+            #   notification = mailer.deliver!(mail)
+            #   expect(notification.disable_email_click_tracking).to eq(true)
+            # end
+
+            it 'supports external_id' do
+              mail['custom_notification_args'] = { 'external_id' => 'Test' }
+              notification = mailer.deliver!(mail)
+              expect(notification.external_id).to eq('Test')
+            end
+
+            it 'supports send_after' do
+              mail['custom_notification_args'] = { 'send_after' => 'Thu Sep 24 2015 14:00:00 GMT-0700 (PDT)' }
+              notification = mailer.deliver!(mail)
+              expect(notification.send_after).to eq('Thu Sep 24 2015 14:00:00 GMT-0700 (PDT)')
+            end
+
+            # NOTE: Though this is supported by the API, Email time of day is not currently supported by the backend
+            it 'supports time of day delivery' do
+              mail['custom_notification_args'] = { 'delayed_option' => 'timezone', 'delivery_time_of_day' => '9:00AM' }
+              notification = mailer.deliver!(mail)
+              expect(notification.delayed_option).to eq('timezone')
+              expect(notification.delivery_time_of_day).to eq('9:00AM')
+            end
+
+            # NOTE: Though this is supported by the API, Email time of day is not currently supported by the backend
+            it 'supports last active delivery' do
+              mail['custom_notification_args'] = { 'delayed_option' => 'last-active' }
+              notification = mailer.deliver!(mail)
+              expect(notification.delayed_option).to eq('last-active')
+            end
+
+            it 'supports throttle_rate_per_minute' do
+              mail['custom_notification_args'] = { 'throttle_rate_per_minute' => 4 }
+              notification = mailer.deliver!(mail)
+              expect(notification.throttle_rate_per_minute).to eq(4)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'rails'
+require_relative '../lib/onesignal/rails/plugin'
+
+APP_KEY = 'TEST_API_KEY'
+APP_ID = '00000000-0000-0000-0000-000000000000'
+
+RSpec.configure do |config|
+  config.before(:each) do |_example|
+    OneSignal::Rails::Plugin.configure do |c|
+      c.app_key = APP_KEY
+      c.app_id = APP_ID
+    end
+  end
+
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: onesignal-rails-plugin
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- OneSignal
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-06-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: onesignal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: rspec
+  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: A custom Rails ActionMailer delivery method which will send emails through
+  your OneSignal integration
+email:
+- devrel@onesignal.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/onesignal/rails/plugin.rb
+- lib/onesignal/rails/plugin/delivery_error.rb
+- lib/onesignal/rails/plugin/delivery_method.rb
+- lib/onesignal/rails/plugin/literals.rb
+- lib/onesignal/rails/plugin/railtie.rb
+- lib/onesignal/rails/plugin/version.rb
+- onesignal-rails-plugin.gemspec
+- spec/lib/onesignal/rails/plugin/delivery_method_spec.rb
+- spec/spec_helper.rb
+homepage: https://onesignal.com/
+licenses:
+- Modified MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: OneSignal for Rails
+test_files:
+- spec/lib/onesignal/rails/plugin/delivery_method_spec.rb
+- spec/spec_helper.rb