onesignal-ruby-rails6 0.3.0.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Mikamai
+
+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:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+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,211 @@
+# OneSignal Ruby Client
+[![Gem Version](https://badge.fury.io/rb/onesignal-ruby.svg)](https://badge.fury.io/rb/onesignal-ruby)
+[![GitHub Actions](https://github.com/mikamai/onesignal-ruby/workflows/Ruby/badge.svg)](https://github.com/mikamai/onesignal-ruby)
+
+A simple, pure Ruby client to the [OneSignal](https://onesignal.com/apps/22bc6dec-5150-4d6d-8628-377259d2dd14/segments) API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'onesignal-ruby'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install onesignal-ruby
+
+## Configuration
+OneSignal requires an App ID and an API Key, which can be found
+on the OneSignal dashboard.
+By default, OneSignal Ruby looks for them in the environment, loading
+`ONESIGNAL_APP_ID` and `ONESIGNAL_API_KEY` variables.
+
+It also defaults to `https://onesignal.com/api/v1` as the API URL.
+
+You can also turn off OneSignal entirely with a boolean flag (for example to avoid sending
+notification while in test or development environments)
+
+It will also use an internal instance of the Ruby Logger at `INFO` level.
+
+To customize those values, call the following snippet during your
+initialization phase.
+
+```ruby
+require 'onesignal'
+
+OneSignal.configure do |config|
+  config.app_id = 'my_app_id'
+  config.api_key = 'my_api_key'
+  config.api_url = 'http://my_api_url'
+  config.active = false
+  config.logger = Logger.new # Any Logger compliant implementation
+end
+```
+## Usage
+
+### Create a notification
+
+Create a `Notification` object.
+```ruby
+# Create headings for different languages. English is required.
+headings = OneSignal::Notification::Headings.new(en: 'Hello!', it: 'Ciao!')
+
+# Create contents for different languages. English is required.
+contents = OneSignal::Notification::Contents.new(en: "I'm a notification!", it: 'Sono una notifica!')
+
+# Select the included (and/or excluded) segments to target
+included_segments = [OneSignal::Segment::ACTIVE_USERS, 'My custom segment']
+
+# Create the Notification object
+notification = OneSignal::Notification.new(headings: headings, contents: contents, included_segments: included_segments)
+```
+
+Then send it.
+```ruby
+ response = OneSignal.send_notification(notification)
+ # => #<OneSignal::Responses::Notification> the created notification
+```
+
+### Fetch a notification
+You can fetch an existing notification given its ID.
+```ruby
+response = OneSignal.fetch_notification(notification_id)
+# => #<OneSignal::Responses::Notification> the created notification
+```
+`OneSignal::Responses::Notification` has the following fields.
+```ruby
+id            # Notification UUID
+successful    # Number of successful deliveries
+failed        # Number of failed deliveries
+converted     # Number of users who have clicked / tapped on your notification.
+remaining     # Number of notifications that have not been sent out yet
+queued_at     # Unix timestamp of enqueuing time
+send_after    # Unix timestamp indicating when notification delivery should begin
+completed_at  # Unix timestamp indicating when notification delivery completed.
+url           # URL associated with the notification
+data          # Custom metadata
+canceled      # Boolean, has the notification been canceled
+headings      # Map of locales to title strings
+contents      # Map of locales to content strings
+
+response.id # => fe82c1ae-54c2-458b-8aad-7edc3e8a96c4
+```
+
+### Attachments
+You can add files, data or images to a notification, or an external URL to open.
+```ruby
+attachments = OneSignal::Attachments.new(
+      data:            { 'test' => 'test' },
+      url:             'http://example.com',
+      ios_attachments: { 'something' => 'drawable resource name or URL.' },
+      android_picture: 'drawable resource name or URL.',
+      amazon_picture:  'drawable resource name or URL.',
+      chrome_picture:  'drawable resource name or URL.'
+)
+
+OneSignal::Notification.new(attachments: attachments)
+```
+
+### Fetch players
+You can fetch all players and devices with a simple method.
+
+```ruby
+players = OneSignal.fetch_players
+# => Array of OneSignal::Responses::Player
+```
+
+Or you can fetch a single player by its ID.
+```ruby
+player = OneSignal.fetch_player(player_id)
+# => #<OneSignal::Responses::Player>
+```
+
+### Filters
+
+Filters can be created with a simple DSL. It closely matches the [JSON reference](https://documentation.onesignal.com/reference#section-send-to-users-based-on-filters), with a few touches of syntax
+sugar.
+
+**Example**
+```ruby
+filters = [
+  OneSignal::Filter.last_session.lesser_than(2).hours_ago!,
+  OneSignal::Filter.session_count.equals(5),
+  OneSignal::Filter::OR,
+  OneSignal::Filter.country.equals('IT')
+]
+
+OneSignal::Notification.new(filters: filters)
+```
+Becomes
+```json
+[
+  {"field":"last_session","relation":"<","hours_ago":"2"},
+  {"field":"session_count","relation":"=","value":"5"},
+  {"operator":"OR"},
+  {"field":"country","relation":"=","value":"IT"}
+]
+```
+
+The operator methods (`#lesser_than`, `#greater_than`, `#equals`, `#not_equals`) are also available through the following shorthands: `<`, `>`, `=`, `!=`.
+
+**Example**
+```ruby
+filters = [
+  OneSignal::Filter.tag('userId') == 5,
+  OneSignal::Filter.session_count < 2,
+  OneSignal::Filter.language != 'en'  
+]
+
+OneSignal::Notification.new(filters: filters)
+```
+
+### Custom Sounds
+You can customize notification sounds by passing a `OneSignal::Sounds` object.
+```ruby
+sounds = OneSignal::Sounds.new(ios: 'ping.wav', android: 'ping')
+OneSignal::Notification.new(sounds: sounds)
+```
+
+### Specific Targets
+If you want to send a notification only to specific targets (a particular user's email or device) you can
+pass a `OneSignal::IncludedTargets` to the notification object.
+See [the official documentation](https://documentation.onesignal.com/reference#section-send-to-specific-devices) for a list of available params.
+```ruby
+included_targets = OneSignal::IncludedTargets.new(include_player_ids: 'test-id-12345')
+OneSignal::Notification.new(included_targets: included_targets)
+```
+
+**WARNING**
+Passing `include_player_ids` alongside other params is prohibited and will raise an `ArgumentError`.
+Either use `include_player_ids` or use the other params.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/mikamai/onesignal-ruby. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+This repo is managed following the [Git Flow](https://danielkummer.github.io/git-flow-cheatsheet/) principles.
+- `master` is the stable, production-ready branch. Never work directly on it. The gem is published from this branch.
+- `develop` is the active development branch. It is supposed to be somewhat stable. Every new feature is merged here once completed, before being released to master.
+- `feature/my-awesome-branch` are personal, dedicated branches for working on actual features. They are merged in develop once completed and then deleted.
+- `hotfix/my-awesome-fix` are special branches dedicated to bugfixes that compromise the library functionality. They are merged
+in both master and develop and then deleted.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the OneSignal Ruby project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'onesignal'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/fixtures/vcr_cassettes/os-csv-export.yml

@@ -0,0 +1,135 @@
+---
+http_interactions:
+- request:
+    method: post
+    uri: https://onesignal.com/api/v1/players/csv_export?app_id=test
+    body:
+      encoding: UTF-8
+      string: '{"app_id":"test"}'
+    headers:
+      User-Agent:
+      - Faraday v0.15.4
+      Content-Type:
+      - application/json
+      Authorization:
+      - Basic ZjI3NDAwY2ItNTM1Yy00OTkwLWE1OTAtNzI0ZjdmNTg1ZTlj
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Date:
+      - Tue, 17 Sep 2019 14:33:01 GMT
+      Content-Type:
+      - application/json; charset=utf-8
+      Transfer-Encoding:
+      - chunked
+      Connection:
+      - keep-alive
+      Set-Cookie:
+      - __cfduid=d10f3912512be2fb143a35a8fb1af30331568730781; expires=Wed, 16-Sep-20
+        14:33:01 GMT; path=/; domain=.onesignal.com; HttpOnly
+      Status:
+      - 200 OK
+      Cache-Control:
+      - max-age=0, private, must-revalidate
+      Access-Control-Allow-Origin:
+      - "*"
+      X-Xss-Protection:
+      - 1; mode=block
+      X-Request-Id:
+      - b5baa4c3-9884-4a26-ad57-9695fe9c85a4
+      Access-Control-Allow-Headers:
+      - SDK-Version
+      Etag:
+      - W/"7965e366a680d7fa0c3b52547dfd736a"
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-Runtime:
+      - '0.169620'
+      X-Content-Type-Options:
+      - nosniff
+      X-Powered-By:
+      - Phusion Passenger 5.3.7
+      Expect-Ct:
+      - max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
+      Server:
+      - cloudflare
+      Cf-Ray:
+      - 517bcaf63e2ed45b-HAM
+    body:
+      encoding: ASCII-8BIT
+      string: '{"csv_file_url":"https://onesignal.s3.amazonaws.com/csv_exports/test/users_abc123.csv.gz"}'
+    http_version: 
+  recorded_at: Tue, 17 Sep 2019 14:33:01 GMT
+- request:
+    method: post
+    uri: https://onesignal.com/api/v1/players/csv_export?app_id=test
+    body:
+      encoding: UTF-8
+      string: '{"app_id":"test","last_active_since":"1568419200"}'
+    headers:
+      User-Agent:
+      - Faraday v0.15.4
+      Content-Type:
+      - application/json
+      Authorization:
+      - Basic ZjI3NDAwY2ItNTM1Yy00OTkwLWE1OTAtNzI0ZjdmNTg1ZTlj
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Date:
+      - Tue, 17 Sep 2019 14:33:01 GMT
+      Content-Type:
+      - application/json; charset=utf-8
+      Transfer-Encoding:
+      - chunked
+      Connection:
+      - keep-alive
+      Set-Cookie:
+      - __cfduid=d10f3912512be2fb143a35a8fb1af30331568730781; expires=Wed, 16-Sep-20
+        14:33:01 GMT; path=/; domain=.onesignal.com; HttpOnly
+      Status:
+      - 200 OK
+      Cache-Control:
+      - max-age=0, private, must-revalidate
+      Access-Control-Allow-Origin:
+      - "*"
+      X-Xss-Protection:
+      - 1; mode=block
+      X-Request-Id:
+      - b5baa4c3-9884-4a26-ad57-9695fe9c85a4
+      Access-Control-Allow-Headers:
+      - SDK-Version
+      Etag:
+      - W/"7965e366a680d7fa0c3b52547dfd736a"
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-Runtime:
+      - '0.169620'
+      X-Content-Type-Options:
+      - nosniff
+      X-Powered-By:
+      - Phusion Passenger 5.3.7
+      Expect-Ct:
+      - max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
+      Server:
+      - cloudflare
+      Cf-Ray:
+      - 517bcaf63e2ed45b-HAM
+    body:
+      encoding: ASCII-8BIT
+      string: '{"csv_file_url":"https://onesignal.s3.amazonaws.com/csv_exports/test/users_def456.csv.gz"}'
+    http_version: 
+  recorded_at: Tue, 17 Sep 2019 14:33:01 GMT
+recorded_with: VCR 4.0.0

data/fixtures/vcr_cassettes/os-fetch-noti.yml

@@ -0,0 +1,76 @@
+---
+http_interactions:
+- request:
+    method: get
+    uri: https://onesignal.com/api/v1/notifications/?app_id
+    body:
+      encoding: US-ASCII
+      string: ''
+    headers:
+      User-Agent:
+      - Faraday v0.15.2
+      Content-Type:
+      - application/json
+      Authorization:
+      - Basic test
+      Accept-Encoding:
+      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
+      Accept:
+      - "*/*"
+  response:
+    status:
+      code: 200
+      message: OK
+    headers:
+      Date:
+      - Thu, 28 Jun 2018 15:30:58 GMT
+      Content-Type:
+      - application/json; charset=utf-8
+      Transfer-Encoding:
+      - chunked
+      Connection:
+      - keep-alive
+      Set-Cookie:
+      - __cfduid=df0001a10af0412855ad6ed0276b466461530199857; expires=Fri, 28-Jun-19
+        15:30:57 GMT; path=/; domain=.onesignal.com; HttpOnly
+      Status:
+      - 200 OK
+      Cache-Control:
+      - public, max-age=7200
+      Access-Control-Allow-Origin:
+      - "*"
+      X-Xss-Protection:
+      - 1; mode=block
+      X-Request-Id:
+      - 5fc751d2-1bc0-46c7-b33f-5579f956f7d2
+      Access-Control-Allow-Headers:
+      - SDK-Version
+      Etag:
+      - W/"ff3055c61c4d74053c0069ab107cbe35"
+      X-Frame-Options:
+      - SAMEORIGIN
+      X-Runtime:
+      - '0.257959'
+      X-Content-Type-Options:
+      - nosniff
+      X-Powered-By:
+      - Phusion Passenger 5.3.2
+      Cf-Cache-Status:
+      - EXPIRED
+      Vary:
+      - Accept-Encoding
+      Expires:
+      - Thu, 28 Jun 2018 17:30:58 GMT
+      Expect-Ct:
+      - max-age=604800, report-uri="https://report-uri.cloudflare.com/cdn-cgi/beacon/expect-ct"
+      Server:
+      - cloudflare
+      Cf-Ray:
+      - 432132975a284334-MXP
+    body:
+      encoding: ASCII-8BIT
+      string: !binary |-
+        {"total_count":26,"offset":0,"limit":50,"notifications":[{"adm_big_picture":null,"adm_group":null,"adm_group_message":null,"adm_large_icon":null,"adm_small_icon":null,"adm_sound":null,"spoken_text":null,"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":null,"android_accent_color":null,"android_group":null,"android_group_message":null,"android_led_color":null,"android_sound":null,"android_visibility":null,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":null,"buttons":null,"canceled":false,"chrome_big_picture":null,"chrome_icon":null,"chrome_web_icon":null,"chrome_web_image":null,"chrome_web_badge":null,"content_available":null,"contents":{"en":"Live Test"},"converted":0,"data":null,"delayed_option":null,"delivery_time_of_day":null,"errored":0,"excluded_segments":[],"failed":0,"firefox_icon":null,"headings":{"en":"This is a live test for OneSignal"},"id":"29e9c2ad-41da-46f0-94c3-e71ee5c103dc","include_player_ids":null,"included_segments":["Active Users"],"ios_badgeCount":null,"ios_badgeType":null,"ios_category":null,"ios_sound":null,"apns_alert":null,"isAdm":false,"isAndroid":true,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":null,"priority":null,"queued_at":1530199857,"remaining":1,"send_after":1530199857,"completed_at":null,"small_icon":null,"successful":0,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":null,"web_buttons":null,"web_push_topic":null,"wp_sound":null,"wp_wns_sound":null},{"adm_big_picture":null,"adm_group":null,"adm_group_message":null,"adm_large_icon":null,"adm_small_icon":null,"adm_sound":null,"spoken_text":null,"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":null,"android_accent_color":null,"android_group":null,"android_group_message":null,"android_led_color":null,"android_sound":null,"android_visibility":null,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":null,"buttons":null,"canceled":false,"chrome_big_picture":null,"chrome_icon":null,"chrome_web_icon":null,"chrome_web_image":null,"chrome_web_badge":null,"content_available":null,"contents":{"en":"Live Test"},"converted":0,"data":null,"delayed_option":null,"delivery_time_of_day":null,"errored":0,"excluded_segments":[],"failed":0,"firefox_icon":null,"headings":{"en":"This is a live test for OneSignal"},"id":"3b3fa37b-9648-4101-bf7b-30c4dc465c03","include_player_ids":null,"included_segments":["Active Users"],"ios_badgeCount":null,"ios_badgeType":null,"ios_category":null,"ios_sound":null,"apns_alert":null,"isAdm":false,"isAndroid":true,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":null,"priority":null,"queued_at":1530199783,"remaining":0,"send_after":1530199783,"completed_at":1530199784,"small_icon":null,"successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":null,"web_buttons":null,"web_push_topic":null,"wp_sound":null,"wp_wns_sound":null},{"adm_big_picture":null,"adm_group":null,"adm_group_message":null,"adm_large_icon":null,"adm_small_icon":null,"adm_sound":null,"spoken_text":null,"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":null,"android_accent_color":null,"android_group":null,"android_group_message":null,"android_led_color":null,"android_sound":null,"android_visibility":null,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":null,"buttons":null,"canceled":false,"chrome_big_picture":null,"chrome_icon":null,"chrome_web_icon":null,"chrome_web_image":null,"chrome_web_badge":null,"content_available":null,"contents":{"en":"Live Test"},"converted":0,"data":null,"delayed_option":null,"delivery_time_of_day":null,"errored":0,"excluded_segments":[],"failed":0,"firefox_icon":null,"headings":{"en":"This is a live test for OneSignal"},"id":"26a28290-ba3c-4f16-9041-ce7227f3addb","include_player_ids":null,"included_segments":["Active Users"],"ios_badgeCount":null,"ios_badgeType":null,"ios_category":null,"ios_sound":null,"apns_alert":null,"isAdm":false,"isAndroid":true,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":null,"priority":null,"queued_at":1530199716,"remaining":0,"send_after":1530199716,"completed_at":1530199716,"small_icon":null,"successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":null,"web_buttons":null,"web_push_topic":null,"wp_sound":null,"wp_wns_sound":null},{"adm_big_picture":null,"adm_group":null,"adm_group_message":null,"adm_large_icon":null,"adm_small_icon":null,"adm_sound":null,"spoken_text":null,"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":null,"android_accent_color":null,"android_group":null,"android_group_message":null,"android_led_color":null,"android_sound":null,"android_visibility":null,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":null,"buttons":null,"canceled":false,"chrome_big_picture":null,"chrome_icon":null,"chrome_web_icon":null,"chrome_web_image":null,"chrome_web_badge":null,"content_available":null,"contents":{"en":"Live Test"},"converted":0,"data":null,"delayed_option":null,"delivery_time_of_day":null,"errored":0,"excluded_segments":[],"failed":0,"firefox_icon":null,"headings":{"en":"This is a live test for OneSignal"},"id":"b04200b1-a08c-4dbc-bd51-7e73757e1726","include_player_ids":null,"included_segments":["Active Users"],"ios_badgeCount":null,"ios_badgeType":null,"ios_category":null,"ios_sound":null,"apns_alert":null,"isAdm":false,"isAndroid":true,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":null,"priority":null,"queued_at":1530199046,"remaining":0,"send_after":1530199046,"completed_at":1530199047,"small_icon":null,"successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":null,"web_buttons":null,"web_push_topic":null,"wp_sound":null,"wp_wns_sound":null},{"adm_big_picture":null,"adm_group":null,"adm_group_message":null,"adm_large_icon":null,"adm_small_icon":null,"adm_sound":null,"spoken_text":null,"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":null,"android_accent_color":null,"android_group":null,"android_group_message":null,"android_led_color":null,"android_sound":null,"android_visibility":null,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":null,"buttons":null,"canceled":false,"chrome_big_picture":null,"chrome_icon":null,"chrome_web_icon":null,"chrome_web_image":null,"chrome_web_badge":null,"content_available":null,"contents":{"en":"Live Test"},"converted":0,"data":null,"delayed_option":null,"delivery_time_of_day":null,"errored":0,"excluded_segments":[],"failed":0,"firefox_icon":null,"headings":{"en":"This is a live test for OneSignal"},"id":"477c0549-ca75-4740-8822-8dfb8f53a9a3","include_player_ids":null,"included_segments":["Active Users"],"ios_badgeCount":null,"ios_badgeType":null,"ios_category":null,"ios_sound":null,"apns_alert":null,"isAdm":false,"isAndroid":true,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":null,"priority":null,"queued_at":1530198999,"remaining":0,"send_after":1530198999,"completed_at":1530199000,"small_icon":null,"successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":null,"web_buttons":null,"web_push_topic":null,"wp_sound":null,"wp_wns_sound":null},{"adm_big_picture":"","adm_group":"","adm_group_message":{"en":""},"adm_large_icon":"","adm_small_icon":"","adm_sound":"","spoken_text":{},"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":false,"android_accent_color":"","android_group":"","android_group_message":{"en":""},"android_led_color":"","android_sound":"","android_visibility":1,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":"","buttons":null,"canceled":false,"chrome_big_picture":"","chrome_icon":"","chrome_web_icon":"","chrome_web_image":"","chrome_web_badge":"","content_available":false,"contents":{"en":"gfdgfdgd"},"converted":0,"data":null,"delayed_option":"immediate","delivery_time_of_day":"3:32PM","errored":0,"excluded_segments":[],"failed":0,"firefox_icon":"","headings":{"en":"dsadsads"},"id":"a42b3604-9096-414a-a39b-0b23c272dda4","include_player_ids":null,"included_segments":["All"],"ios_badgeCount":1,"ios_badgeType":"None","ios_category":"","ios_sound":"","apns_alert":{},"isAdm":false,"isAndroid":true,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":"","priority":5,"queued_at":1530192768,"remaining":0,"send_after":1530192768,"completed_at":1530192769,"small_icon":"","successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":"","web_buttons":null,"web_push_topic":null,"wp_sound":"","wp_wns_sound":""},{"adm_big_picture":"","adm_group":"","adm_group_message":{"en":""},"adm_large_icon":"","adm_small_icon":"","adm_sound":"","spoken_text":{},"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":false,"android_accent_color":"","android_group":"","android_group_message":{"en":""},"android_led_color":"","android_sound":"","android_visibility":1,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":"","buttons":"[{\"id\":\"one\",\"text\":\"One\",\"icon\":\"ic_menu_share\"}]","canceled":false,"chrome_big_picture":"","chrome_icon":"","chrome_web_icon":"","chrome_web_image":"","chrome_web_badge":"","content_available":false,"contents":{"en":"dsdsd"},"converted":1,"data":null,"delayed_option":"immediate","delivery_time_of_day":"1:01PM","errored":0,"excluded_segments":[],"failed":0,"firefox_icon":"","headings":{"en":"Test Pulsanti"},"id":"957451e0-baf3-48e8-bb6a-3775220bec95","include_player_ids":null,"included_segments":["All"],"ios_badgeCount":1,"ios_badgeType":"Increase","ios_category":"","ios_sound":"","apns_alert":{},"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":"","priority":5,"queued_at":1530183833,"remaining":0,"send_after":1530183833,"completed_at":1530183834,"small_icon":"","successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":"","web_buttons":null,"web_push_topic":null,"wp_sound":"","wp_wns_sound":""},{"adm_big_picture":"","adm_group":"","adm_group_message":{"en":""},"adm_large_icon":"","adm_small_icon":"","adm_sound":"","spoken_text":{},"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":false,"android_accent_color":"","android_group":"","android_group_message":{"en":""},"android_led_color":"","android_sound":"","android_visibility":1,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":"","buttons":null,"canceled":false,"chrome_big_picture":"","chrome_icon":"","chrome_web_icon":"","chrome_web_image":"","chrome_web_badge":"","content_available":false,"contents":{"en":"dsfdasfdas"},"converted":0,"data":null,"delayed_option":"immediate","delivery_time_of_day":"12:52PM","errored":0,"excluded_segments":[],"failed":0,"firefox_icon":"","headings":{"en":"fdsfdasf"},"id":"f246f6ae-50fd-4e06-a9dd-45080d4e3290","include_player_ids":null,"included_segments":["All"],"ios_badgeCount":1,"ios_badgeType":"Increase","ios_category":"","ios_sound":"reward.wav","apns_alert":{},"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":"","priority":5,"queued_at":1530183145,"remaining":0,"send_after":1530183145,"completed_at":1530183145,"small_icon":"","successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":"","web_buttons":null,"web_push_topic":null,"wp_sound":"","wp_wns_sound":""},{"adm_big_picture":"","adm_group":"","adm_group_message":{"en":""},"adm_large_icon":"","adm_small_icon":"","adm_sound":"","spoken_text":{},"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":false,"android_accent_color":"","android_group":"","android_group_message":{"en":""},"android_led_color":"","android_sound":"","android_visibility":1,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":"","buttons":null,"canceled":false,"chrome_big_picture":"","chrome_icon":"","chrome_web_icon":"","chrome_web_image":"","chrome_web_badge":"","content_available":false,"contents":{"en":"test test 1"},"converted":0,"data":null,"delayed_option":"immediate","delivery_time_of_day":"12:51PM","errored":0,"excluded_segments":[],"failed":0,"firefox_icon":"","headings":{"en":"test test"},"id":"9e827501-3f6d-4f27-9d50-8ecf5b6e43e1","include_player_ids":null,"included_segments":["All"],"ios_badgeCount":1,"ios_badgeType":"Increase","ios_category":"","ios_sound":"reward.wav","apns_alert":{},"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":"","priority":5,"queued_at":1530183107,"remaining":0,"send_after":1530183107,"completed_at":1530183108,"small_icon":"","successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":"","web_buttons":null,"web_push_topic":null,"wp_sound":"","wp_wns_sound":""},{"adm_big_picture":"","adm_group":"","adm_group_message":{"en":""},"adm_large_icon":"","adm_small_icon":"","adm_sound":"","spoken_text":{},"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":false,"android_accent_color":"","android_group":"","android_group_message":{"en":""},"android_led_color":"","android_sound":"","android_visibility":1,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":"","buttons":null,"canceled":false,"chrome_big_picture":"","chrome_icon":"","chrome_web_icon":"","chrome_web_image":"","chrome_web_badge":"","content_available":false,"contents":{"en":"test 2"},"converted":0,"data":null,"delayed_option":"immediate","delivery_time_of_day":"12:20PM","errored":0,"excluded_segments":[],"failed":0,"firefox_icon":"","headings":{"en":"Test 2"},"id":"99253028-b58f-47b1-b81d-5400f1df2985","include_player_ids":null,"included_segments":["All"],"ios_badgeCount":1,"ios_badgeType":"None","ios_category":"","ios_sound":"newCampaign.wav","apns_alert":{},"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":"","priority":5,"queued_at":1530181280,"remaining":0,"send_after":1530181280,"completed_at":1530181280,"small_icon":"","successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":"","web_buttons":null,"web_push_topic":null,"wp_sound":"","wp_wns_sound":""},{"adm_big_picture":"","adm_group":"","adm_group_message":{"en":""},"adm_large_icon":"","adm_small_icon":"","adm_sound":"","spoken_text":{},"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":false,"android_accent_color":"","android_group":"","android_group_message":{"en":""},"android_led_color":"","android_sound":"","android_visibility":1,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":"","buttons":null,"canceled":false,"chrome_big_picture":"","chrome_icon":"","chrome_web_icon":"","chrome_web_image":"","chrome_web_badge":"","content_available":false,"contents":{"en":"test 1"},"converted":0,"data":null,"delayed_option":"immediate","delivery_time_of_day":"12:18PM","errored":0,"excluded_segments":[],"failed":0,"firefox_icon":"","headings":{"en":"Reward 1"},"id":"95c4b449-7b7b-445d-a36b-26ae639716b4","include_player_ids":null,"included_segments":["All"],"ios_badgeCount":1,"ios_badgeType":"None","ios_category":"","ios_sound":"reward.wav","apns_alert":{},"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":"","priority":5,"queued_at":1530181158,"remaining":0,"send_after":1530181158,"completed_at":1530181159,"small_icon":"","successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":"","web_buttons":null,"web_push_topic":null,"wp_sound":"","wp_wns_sound":""},{"adm_big_picture":"","adm_group":"","adm_group_message":{"en":""},"adm_large_icon":"","adm_small_icon":"","adm_sound":"","spoken_text":{},"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":false,"android_accent_color":"","android_group":"","android_group_message":{"en":""},"android_led_color":"","android_sound":"","android_visibility":1,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":"","buttons":"[{\"id\":\"1\",\"text\":\"pippo\",\"icon\":\"\"},{\"id\":\"2\",\"text\":\"pluto\",\"icon\":\"\"},{\"id\":\"3\",\"text\":\"quaqua\",\"icon\":\"\"}]","canceled":false,"chrome_big_picture":"","chrome_icon":"","chrome_web_icon":"","chrome_web_image":"","chrome_web_badge":"","content_available":false,"contents":{"en":"fsfa"},"converted":1,"data":null,"delayed_option":"immediate","delivery_time_of_day":"11:46AM","errored":0,"excluded_segments":[],"failed":0,"firefox_icon":"","headings":{"en":"dsadasda"},"id":"faf58d2c-f45e-4ab5-9573-077e4643517b","include_player_ids":null,"included_segments":["All"],"ios_badgeCount":1,"ios_badgeType":"None","ios_category":"","ios_sound":"","apns_alert":{},"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":"","priority":5,"queued_at":1530179201,"remaining":0,"send_after":1530179201,"completed_at":1530179201,"small_icon":"","successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":"","web_buttons":null,"web_push_topic":null,"wp_sound":"","wp_wns_sound":""},{"adm_big_picture":"","adm_group":"","adm_group_message":{"en":""},"adm_large_icon":"","adm_small_icon":"","adm_sound":"","spoken_text":{},"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":false,"android_accent_color":"","android_group":"","android_group_message":{"en":""},"android_led_color":"","android_sound":"","android_visibility":1,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":"","buttons":null,"canceled":false,"chrome_big_picture":"","chrome_icon":"","chrome_web_icon":"","chrome_web_image":"","chrome_web_badge":"","content_available":false,"contents":{"en":"visita il nostro sito web 2"},"converted":1,"data":null,"delayed_option":"immediate","delivery_time_of_day":"11:44AM","errored":0,"excluded_segments":[],"failed":0,"firefox_icon":"","headings":{"en":"dasdsad"},"id":"02a4f2fb-a6b6-42c8-a95d-b5aa87234a99","include_player_ids":null,"included_segments":["All"],"ios_badgeCount":1,"ios_badgeType":"None","ios_category":"","ios_sound":"","apns_alert":{},"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":"","priority":5,"queued_at":1530179126,"remaining":0,"send_after":1530179126,"completed_at":1530179126,"small_icon":"","successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":"http://wordpress-184122-541281.cloudwaysapps.com/","web_buttons":null,"web_push_topic":null,"wp_sound":"","wp_wns_sound":""},{"adm_big_picture":"","adm_group":"","adm_group_message":{"en":""},"adm_large_icon":"","adm_small_icon":"","adm_sound":"","spoken_text":{},"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":false,"android_accent_color":"","android_group":"","android_group_message":{"en":""},"android_led_color":"","android_sound":"","android_visibility":1,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":"","buttons":null,"canceled":false,"chrome_big_picture":"","chrome_icon":"","chrome_web_icon":"","chrome_web_image":"","chrome_web_badge":"","content_available":false,"contents":{"en":"visita il nostro sito web"},"converted":1,"data":{"key1":"pippo"},"delayed_option":"immediate","delivery_time_of_day":"11:38AM","errored":0,"excluded_segments":[],"failed":0,"firefox_icon":"","headings":{"en":"Ciao ciaone"},"id":"692f998e-f73d-4dde-bf59-458693586b7f","include_player_ids":null,"included_segments":["All"],"ios_badgeCount":1,"ios_badgeType":"None","ios_category":"","ios_sound":"","apns_alert":{},"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":"","priority":5,"queued_at":1530179061,"remaining":0,"send_after":1530179061,"completed_at":1530179062,"small_icon":"","successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":"http://wordpress-184122-541281.cloudwaysapps.com/","web_buttons":null,"web_push_topic":null,"wp_sound":"","wp_wns_sound":""},{"adm_big_picture":null,"adm_group":null,"adm_group_message":null,"adm_large_icon":null,"adm_small_icon":null,"adm_sound":null,"spoken_text":null,"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":null,"android_accent_color":null,"android_group":null,"android_group_message":null,"android_led_color":null,"android_sound":null,"android_visibility":null,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":null,"buttons":null,"canceled":false,"chrome_big_picture":null,"chrome_icon":null,"chrome_web_icon":null,"chrome_web_image":null,"chrome_web_badge":null,"content_available":null,"contents":{"en":"Live Test"},"converted":1,"data":null,"delayed_option":null,"delivery_time_of_day":null,"errored":0,"excluded_segments":[],"failed":0,"firefox_icon":null,"headings":{"en":"This is a live test for OneSignal"},"id":"fe82c1ae-54c2-458b-8aad-7edc3e8a96c4","include_player_ids":null,"included_segments":["Active Users"],"ios_badgeCount":null,"ios_badgeType":null,"ios_category":null,"ios_sound":null,"apns_alert":null,"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":null,"priority":null,"queued_at":1530178925,"remaining":0,"send_after":1530178925,"completed_at":1530178925,"small_icon":null,"successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":null,"web_buttons":null,"web_push_topic":null,"wp_sound":null,"wp_wns_sound":null},{"adm_big_picture":null,"adm_group":null,"adm_group_message":null,"adm_large_icon":null,"adm_small_icon":null,"adm_sound":null,"spoken_text":null,"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":null,"android_accent_color":null,"android_group":null,"android_group_message":null,"android_led_color":null,"android_sound":null,"android_visibility":null,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":null,"buttons":null,"canceled":false,"chrome_big_picture":null,"chrome_icon":null,"chrome_web_icon":null,"chrome_web_image":null,"chrome_web_badge":null,"content_available":null,"contents":{"en":"Live Test"},"converted":0,"data":null,"delayed_option":null,"delivery_time_of_day":null,"errored":0,"excluded_segments":[],"failed":0,"firefox_icon":null,"headings":{"en":"This is a live test for OneSignal"},"id":"2853afc3-a6f4-4900-86d4-3b02b949f00d","include_player_ids":null,"included_segments":["Active Users"],"ios_badgeCount":null,"ios_badgeType":null,"ios_category":null,"ios_sound":null,"apns_alert":null,"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":null,"priority":null,"queued_at":1530178846,"remaining":0,"send_after":1530178846,"completed_at":1530178846,"small_icon":null,"successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":null,"web_buttons":null,"web_push_topic":null,"wp_sound":null,"wp_wns_sound":null},{"adm_big_picture":null,"adm_group":null,"adm_group_message":null,"adm_large_icon":null,"adm_small_icon":null,"adm_sound":null,"spoken_text":null,"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":null,"android_accent_color":null,"android_group":null,"android_group_message":null,"android_led_color":null,"android_sound":null,"android_visibility":null,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":null,"buttons":null,"canceled":false,"chrome_big_picture":null,"chrome_icon":null,"chrome_web_icon":null,"chrome_web_image":null,"chrome_web_badge":null,"content_available":null,"contents":{"en":"Live Test"},"converted":1,"data":null,"delayed_option":null,"delivery_time_of_day":null,"errored":0,"excluded_segments":[],"failed":0,"firefox_icon":null,"headings":{"en":"This is a live test for OneSignal"},"id":"ba8a93e0-7962-4e32-a201-e81eb8a46415","include_player_ids":null,"included_segments":["Active Users"],"ios_badgeCount":null,"ios_badgeType":null,"ios_category":null,"ios_sound":null,"apns_alert":null,"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":null,"priority":null,"queued_at":1530178780,"remaining":0,"send_after":1530178780,"completed_at":1530178781,"small_icon":null,"successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":null,"web_buttons":null,"web_push_topic":null,"wp_sound":null,"wp_wns_sound":null},{"adm_big_picture":null,"adm_group":null,"adm_group_message":null,"adm_large_icon":null,"adm_small_icon":null,"adm_sound":null,"spoken_text":null,"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":null,"android_accent_color":null,"android_group":null,"android_group_message":null,"android_led_color":null,"android_sound":null,"android_visibility":null,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":null,"buttons":null,"canceled":false,"chrome_big_picture":null,"chrome_icon":null,"chrome_web_icon":null,"chrome_web_image":null,"chrome_web_badge":null,"content_available":null,"contents":{"en":"Live Test"},"converted":1,"data":null,"delayed_option":null,"delivery_time_of_day":null,"errored":0,"excluded_segments":[],"failed":0,"firefox_icon":null,"headings":{"en":"This is a live test for OneSignal"},"id":"df39ddbc-666b-4ec5-a2d4-f9e1248c2f3f","include_player_ids":null,"included_segments":["Active Users"],"ios_badgeCount":null,"ios_badgeType":null,"ios_category":null,"ios_sound":null,"apns_alert":null,"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":null,"priority":null,"queued_at":1530178734,"remaining":0,"send_after":1530178734,"completed_at":1530178734,"small_icon":null,"successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":null,"web_buttons":null,"web_push_topic":null,"wp_sound":null,"wp_wns_sound":null},{"adm_big_picture":"","adm_group":"","adm_group_message":{"en":""},"adm_large_icon":"","adm_small_icon":"","adm_sound":"","spoken_text":{},"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":false,"android_accent_color":"","android_group":"","android_group_message":{"en":""},"android_led_color":"","android_sound":"","android_visibility":1,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":"","buttons":null,"canceled":false,"chrome_big_picture":"","chrome_icon":"","chrome_web_icon":"","chrome_web_image":"","chrome_web_badge":"","content_available":false,"contents":{"en":"Sgrignignì"},"converted":1,"data":null,"delayed_option":"immediate","delivery_time_of_day":"11:33AM","errored":0,"excluded_segments":[],"failed":0,"firefox_icon":"","headings":{"en":"Ciao"},"id":"b122489a-4854-4653-81b3-f16298dc4d96","include_player_ids":null,"included_segments":["Active Users"],"ios_badgeCount":1,"ios_badgeType":"None","ios_category":"","ios_sound":"","apns_alert":{},"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":"","priority":5,"queued_at":1530178586,"remaining":0,"send_after":1530178587,"completed_at":1530178587,"small_icon":"","successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":"","web_buttons":null,"web_push_topic":null,"wp_sound":"","wp_wns_sound":""},{"adm_big_picture":null,"adm_group":null,"adm_group_message":null,"adm_large_icon":null,"adm_small_icon":null,"adm_sound":null,"spoken_text":null,"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":null,"android_accent_color":null,"android_group":null,"android_group_message":null,"android_led_color":null,"android_sound":null,"android_visibility":null,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":null,"buttons":null,"canceled":false,"chrome_big_picture":null,"chrome_icon":null,"chrome_web_icon":null,"chrome_web_image":null,"chrome_web_badge":null,"content_available":null,"contents":{"en":"Live Test"},"converted":0,"data":null,"delayed_option":null,"delivery_time_of_day":null,"errored":0,"excluded_segments":[],"failed":0,"firefox_icon":null,"headings":{"en":"This is a live test for OneSignal"},"id":"c3fb0ee4-bcdd-4b77-a92d-022b463a898f","include_player_ids":null,"included_segments":["Active Users"],"ios_badgeCount":null,"ios_badgeType":null,"ios_category":null,"ios_sound":null,"apns_alert":null,"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":null,"priority":null,"queued_at":1530178494,"remaining":0,"send_after":1530178494,"completed_at":1530178494,"small_icon":null,"successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":null,"web_buttons":null,"web_push_topic":null,"wp_sound":null,"wp_wns_sound":null},{"adm_big_picture":null,"adm_group":null,"adm_group_message":null,"adm_large_icon":null,"adm_small_icon":null,"adm_sound":null,"spoken_text":null,"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":null,"android_accent_color":null,"android_group":null,"android_group_message":null,"android_led_color":null,"android_sound":null,"android_visibility":null,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":null,"buttons":null,"canceled":false,"chrome_big_picture":null,"chrome_icon":null,"chrome_web_icon":null,"chrome_web_image":null,"chrome_web_badge":null,"content_available":null,"contents":{"en":"Live Test"},"converted":0,"data":null,"delayed_option":null,"delivery_time_of_day":null,"errored":0,"excluded_segments":[],"failed":0,"firefox_icon":null,"headings":{"en":"This is a live test for OneSignal"},"id":"902e258f-23c6-4d5e-b038-ccc14ef74508","include_player_ids":null,"included_segments":["Active Users"],"ios_badgeCount":null,"ios_badgeType":null,"ios_category":null,"ios_sound":null,"apns_alert":null,"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":null,"priority":null,"queued_at":1530178471,"remaining":0,"send_after":1530178471,"completed_at":1530178472,"small_icon":null,"successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":null,"web_buttons":null,"web_push_topic":null,"wp_sound":null,"wp_wns_sound":null},{"adm_big_picture":null,"adm_group":null,"adm_group_message":null,"adm_large_icon":null,"adm_small_icon":null,"adm_sound":null,"spoken_text":null,"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":null,"android_accent_color":null,"android_group":null,"android_group_message":null,"android_led_color":null,"android_sound":null,"android_visibility":null,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":null,"buttons":null,"canceled":false,"chrome_big_picture":null,"chrome_icon":null,"chrome_web_icon":null,"chrome_web_image":null,"chrome_web_badge":null,"content_available":null,"contents":{"en":"Sgrigninì"},"converted":1,"data":null,"delayed_option":null,"delivery_time_of_day":null,"errored":0,"excluded_segments":[],"failed":0,"firefox_icon":null,"headings":{"en":"Sgrigninì"},"id":"88e51c28-5592-456f-b7e5-fd06cb5be148","include_player_ids":null,"included_segments":["Active Users","All"],"ios_badgeCount":null,"ios_badgeType":null,"ios_category":null,"ios_sound":null,"apns_alert":null,"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":null,"priority":null,"queued_at":1530178287,"remaining":0,"send_after":1530178287,"completed_at":1530178288,"small_icon":null,"successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":null,"web_buttons":null,"web_push_topic":null,"wp_sound":null,"wp_wns_sound":null},{"adm_big_picture":null,"adm_group":null,"adm_group_message":null,"adm_large_icon":null,"adm_small_icon":null,"adm_sound":null,"spoken_text":null,"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":null,"android_accent_color":null,"android_group":null,"android_group_message":null,"android_led_color":null,"android_sound":null,"android_visibility":null,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":null,"buttons":null,"canceled":false,"chrome_big_picture":null,"chrome_icon":null,"chrome_web_icon":null,"chrome_web_image":null,"chrome_web_badge":null,"content_available":null,"contents":{"en":"Sgrigninì"},"converted":1,"data":null,"delayed_option":null,"delivery_time_of_day":null,"errored":0,"excluded_segments":[],"failed":0,"firefox_icon":null,"headings":{"en":"Sgrigninì"},"id":"4ab0f073-9748-4189-8aa7-90d765050325","include_player_ids":null,"included_segments":["Active Users","All"],"ios_badgeCount":null,"ios_badgeType":null,"ios_category":null,"ios_sound":null,"apns_alert":null,"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":null,"priority":null,"queued_at":1530178268,"remaining":0,"send_after":1530178268,"completed_at":1530178269,"small_icon":null,"successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":null,"web_buttons":null,"web_push_topic":null,"wp_sound":null,"wp_wns_sound":null},{"adm_big_picture":"","adm_group":"","adm_group_message":{"en":""},"adm_large_icon":"","adm_small_icon":"","adm_sound":"","spoken_text":{},"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":false,"android_accent_color":"","android_group":"","android_group_message":{"en":""},"android_led_color":"","android_sound":"","android_visibility":1,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":"","buttons":null,"canceled":false,"chrome_big_picture":"","chrome_icon":"","chrome_web_icon":"","chrome_web_image":"","chrome_web_badge":"","content_available":false,"contents":{"en":"Sgrignignì"},"converted":1,"data":null,"delayed_option":"immediate","delivery_time_of_day":"11:24AM","errored":0,"excluded_segments":[],"failed":0,"firefox_icon":"","headings":{"en":"Ciao 2"},"id":"99c2a984-5733-40eb-b0b6-cb615eb24ba9","include_player_ids":null,"included_segments":["All"],"ios_badgeCount":1,"ios_badgeType":"None","ios_category":"","ios_sound":"","apns_alert":{},"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":"","priority":5,"queued_at":1530177905,"remaining":0,"send_after":1530177905,"completed_at":1530177906,"small_icon":"","successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":"","web_buttons":null,"web_push_topic":null,"wp_sound":"","wp_wns_sound":""},{"adm_big_picture":"","adm_group":"","adm_group_message":{"en":""},"adm_large_icon":"","adm_small_icon":"","adm_sound":"","spoken_text":{},"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":false,"android_accent_color":"","android_group":"","android_group_message":{"en":""},"android_led_color":"","android_sound":"","android_visibility":1,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":"","buttons":null,"canceled":false,"chrome_big_picture":"","chrome_icon":"","chrome_web_icon":"","chrome_web_image":"","chrome_web_badge":"","content_available":false,"contents":{"en":"Sgrignignà"},"converted":1,"data":null,"delayed_option":"immediate","delivery_time_of_day":"11:23AM","errored":0,"excluded_segments":[],"failed":0,"firefox_icon":"","headings":{"en":"Ciao"},"id":"c8d5a93b-cd58-4439-9966-ae77acf1170d","include_player_ids":null,"included_segments":["Active Users"],"ios_badgeCount":1,"ios_badgeType":"None","ios_category":"","ios_sound":"","apns_alert":{},"isAdm":false,"isAndroid":false,"isChrome":false,"isChromeWeb":false,"isAlexa":false,"isFirefox":false,"isIos":true,"isSafari":false,"isWP":false,"isWP_WNS":false,"isEdge":false,"large_icon":"","priority":5,"queued_at":1530177877,"remaining":0,"send_after":1530177877,"completed_at":1530177878,"small_icon":"","successful":1,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":"","web_buttons":null,"web_push_topic":null,"wp_sound":"","wp_wns_sound":""},{"adm_big_picture":null,"adm_group":null,"adm_group_message":null,"adm_large_icon":null,"adm_small_icon":null,"adm_sound":null,"spoken_text":null,"alexa_ssml":null,"alexa_display_title":null,"amazon_background_data":null,"android_accent_color":null,"android_group":null,"android_group_message":null,"android_led_color":null,"android_sound":null,"android_visibility":null,"app_id":"22bc6dec-5150-4d6d-8628-377259d2dd14","big_picture":null,"buttons":null,"canceled":false,"chrome_big_picture":null,"chrome_icon":null,"chrome_web_icon":null,"chrome_web_image":null,"chrome_web_badge":null,"content_available":null,"contents":{},"converted":0,"data":null,"delayed_option":"immediate","delivery_time_of_day":"5:12PM","errored":1,"excluded_segments":[],"failed":0,"firefox_icon":null,"headings":{},"id":"b45ce197-a79b-4e36-9923-54a9259c145b","include_player_ids":null,"included_segments":["Test Users"],"ios_badgeCount":null,"ios_badgeType":null,"ios_category":null,"ios_sound":null,"apns_alert":{},"isAdm":null,"isAndroid":null,"isChrome":null,"isChromeWeb":null,"isAlexa":null,"isFirefox":null,"isIos":null,"isSafari":null,"isWP":null,"isWP_WNS":null,"isEdge":null,"large_icon":null,"priority":null,"queued_at":1530112461,"remaining":0,"send_after":1530112461,"completed_at":1530112463,"small_icon":null,"successful":0,"tags":null,"filters":null,"template_id":null,"ttl":null,"url":null,"web_buttons":null,"web_push_topic":null,"wp_sound":null,"wp_wns_sound":null}]}
+    http_version: 
+  recorded_at: Thu, 28 Jun 2018 15:30:58 GMT
+recorded_with: VCR 4.0.0