magicbell 0.2.0 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b556f6bac34d0deac121d7b456b3322f918e3f77b4e82f0cdcbd8cef395d32d1
-  data.tar.gz: 6a56c2b7331c5f3296293f8d2a4bbef8b785bdb762e694b506cab3ac28f21b79
+  metadata.gz: 68c41d47dfcb956fd6ce283573619aafe27c5dc8ecae3db01807ae442afce912
+  data.tar.gz: 6dc6769e62c3b105a675854ccb0ea683f01b425a5d3fc1836fd962f1e370b9fc
 SHA512:
-  metadata.gz: a6139d8789a33f4f5cb45216106d86d7f78c9b1fb9743af3115d4ff9f193035a6c3565ebca3195a130529f81d7110ee8fecbbf5790004642b13c4c56887ba53c
-  data.tar.gz: 5f2f592ea6a3f13500a084a468118e2bc6ad68a7d0e48a5a087e728b052fa20bd1b6e17a09faa37fe5ddaf5b55f5b4975a231f330a98421de5fdb0f806937367
+  metadata.gz: 24b81b3179c672118ac6550a80c8e28bfdb73c293b9f96a1c8ca88e7836c36157eed6ab8fa5d7850199674cdc81770ab237dc5218c28d637f281c787e04b093f
+  data.tar.gz: edb2e6dcdc5e5827b55d4a75067c386a6278dddf52d70ea614657a47a7abcbcccef47e3255ef0918a8af4bbd053f888861a420989db248b5e37ee3d94083f784

data/README.md

@@ -1,137 +1,213 @@
-# magicbell-rails
+# magicbell-ruby
 
-Convert your email notifications to an in-app notification center. This gem makes it easy to add [MagicBell's](https://magicbell.io/) notification center widget to your rails app.
+[MagicBell](https://magicbell.io) is an embeddable Notification Inbox for web & mobile applications.
 
-<img width="415" alt="magicbell notification center widget" src="https://user-images.githubusercontent.com/1789832/28327736-f3503f44-6c01-11e7-9a72-c15023db18c6.png">
+Please familiarlize yourself with the [core concepts of MagicBell](https://developer.magicbell.io/docs/core-concepts) before using this gem.
+
+This gem
+
+1. Makes it easy to interact with [MagicBell's REST API](https://developer.magicbell.io/reference) from Ruby.
+
+   You can use it to create a notification in your MagicBell project etc.
+
+2. Can BCC your ActionMailer email notifications to MagicBell if you rather not use MagicBell's API in your Rails application.
+
+   MagicBell will create an in-app notification from any email notification that's blind copied to it.
+
+3. Helps you calculate the HMAC for a user's email or external_id when you turn on [HMAC Authentication](https://developer.magicbell.io/docs/turn-on-hmac-authentication) for your MagicBell project
+
+<img width="415" alt="MagicBell Notification Inbox" src="https://files.readme.io/c09b21a-image1.png">
 
 ## Installation
 
-Add the magicbell gem to your app's Gemfile
+Sign up at magicbell.io and obtain your MagicBell project's API Key and API Secret from the "Settings" section in your MagicBell dashboard.
+
+Add the gem to your app's Gemfile
 
 ```ruby
 gem "magicbell"
 ```
 
-Run
+and install the gem
 
 ```
 bundle install
 ```
 
-Create the initializer file `config/initializers/magicbell.rb` and add your MagicBell credentials there.
+The gem will automatically pick your MagicBell project's API Key and API Secret from the `MAGICBELL_API_KEY` and `MAGICBELL_API_SECRET` environment variables. Alternatively, provide the API Key and API Secret in an initializer
 
 ```
 vim config/initializers/magicbell.rb
 ```
 
 ```ruby
+# config/initializers/magicbell.rb
+
 MagicBell.configure do |config|
   config.api_key = "your_magicbell_api_key"
   config.api_secret = "your_magicbell_api_secret"
-  config.project_id = 1 # your magicbell project id
-  config.magic_address = "your_magicell_magic_address@ring.magicbell.io"
 end
 ```
 
-If you haven't signed up for MagicBell yet and don't have credentials, visit https://magicbell.io/, sign in with your google account and create a Project.
-
-Add MagicBell's icon to your app's interface. Our customers usually add MagicBell's icon to their app's navigation bar.
-
-```html
-<div id="magicbell_notifications" style="display:inline-block;">
-  <i class="icon-magicbell"></i>
-</div>
-```
-
-Create the partial file `config/layouts/_magicbell.html.erb` and copy paste the code below
-
-```erb
-<!-- MagicBell notification center widget -->
-<script>
-  $('<link/>', {
-    rel: 'stylesheet',
-    type: 'text/css',
-    href: "<%= MagicBell::EXTRAS_CSS_URL %>"
-  }).appendTo('head');
-  $(document).ready(function () {
-    // Initialize the widget after fetching its javascript
-    $.getScript("<%= MagicBell::WIDGET_JAVASCRIPT_URL %>", initializeMagicBell);
-  });
-  function initializeMagicBell() {
-    MagicBell.initialize({
-      target: document.getElementById('magicbell_notifications'),
-      projectId: "<%= MagicBell.project_id %>",
-      apiKey: "<%= MagicBell.api_key %>",
-      userEmail: "<%= current_user.email %>",
-      userKey: "<%= MagicBell.user_key(current_user.email) %>"
-    });
-  }
-</script>
+## API Wrapper
+
+This gem makes it easy to interact with MagicBell's REST API https://developer.magicbell.io/reference from Ruby
+
+### Create a notification
+
+Send a notification to one or many users by identifying them with their email address
+
+```ruby
+magicbell = MagicBell::Client.new
+magicbell.create_notification(
+  "title" => "Rob assigned a task to you",
+  "recipients" => [
+    {
+      email: "joe@example.com"
+    },
+  ]
+)
 ```
 
-Render the `_magicbell.html.erb` partial in your app's layout. Say, your app's layout file is `config/layouts/app.html.erb`, render the partial at the bottom. Here's an example
+You can also identify users with their `external_id`, which is their ID in your database. That way, if their email address changes, they'd still have access to their notifications. You'll need to make sure you identify them with their `externalID` [in your frontend](https://developer.magicbell.io/docs/browser-js#identifying-users).
 
-```erb
-<html>
-  <body>
-    <p>This is your app's layout</p>
-  </body>
+```ruby
+     magicbell.create_notification(
+          title: "Welcome to Muziboo",
+          recipients: [{
+            external_id: "id_in_your_database"
+          }]
+        )
+```
+
+You can even provide content for the notification and a URL to redirect the user to when they click on the notification the MagicBell Notification Inbox
 
-  <%= render layouts/magicbell %>
-</html>
+```ruby
+magicbell = MagicBell::Client.new
+magicbell.create_notification(
+  "title" => "Rob assigned to a task to you",
+  "recipients" => [
+    {
+      email: "joe@example.com"
+    },
+  ],
+  "content": "Hey Joe, can give this customer a demo of our app?",
+  "action_url" => "https://yourwebsite.com/task_path"
+)
 ```
 
-Now, call the `ring_the_magicbell` method in your notification mailers. Here's an example
+### Fetch a user's notifications
+
+Fetch a user's notifications
 
 ```ruby
-class NotificationMailer < ActionMailer::Base
-  # This method will bcc your email notifications to your magicbell magic address
-  #
-  # Upon receiving the bcc'ed email notifications, magicbell.io will automatically
-  # create in-app notications for users
-  ring_the_magicbell
+magicbell = MagicBell::Client.new
+user = magicbell.user_with_email("joe@example.com")
+user_notifications = user.notifications
+user_notifications.each { |user_notification| puts user_notification.attribute("title") }
+```
 
-  # This is an email notification in your app
-  def new_comment
-    # ...
-  end
-  
-  # This is another email notification in your app
-  def mentioned
-    # ...
+Please note that the example above fetches the user's 15 most recent notification (the default number of notifications per page) If you'd like to fetch subsequent pages, use
+
+```ruby
+magicbell = MagicBell::Client.new
+user = magicbell.user_with_email("joe@example.com")
+user_notifications = user.notifications
+user_notifications.each_page do |page|
+  page.each do |user_notification|
+    puts user_notification.attribute("title")
   end
 end
 ```
 
-Deploy your app.
+### Mark a user notification as read/unread
+
+```ruby
+magicbell = MagicBell::Client.new
+user = magicbell.user_with_email("joe@example.com")
+user_notification = user.notifications.first
+user_notification.mark_as_read
+user_notification.mark_as_unread
+```
+
+### Mark all notifications of a user as read/seen
+
+```ruby
+magicbell = MagicBell::Client.new
+user = magicbell.user_with_email("joe@example.com")
+user.mark_all_notifications_as_read
+user.mark_all_notifications_as_seen
+```
 
-That's it! All your users now benefit from having in-app notifications.
+### Error handling
 
-If you've trouble adding MagicBell to your app or find yourself stuck, please don't hestitate to reach out to us at hana@magicbell.io We usually respond within 24 hours (often much lesser).
+Please note that the gem raises a `MagicBell::Client::HTTPError` if an API returns a non 2xx response
 
-## Advanced Features
+```ruby
+begin
+  magicbell = MagicBell::Client.new
+  magicbell.create_notification(
+    "title" => "Rob assigned to a task to you"
+  )
+rescue MagicBell::Client::HTTPError => e
+  # Report the error to your error tracker
+  error_context = {
+    response_status: e.response_status,
+    response_headers: e.response_headers,
+    response_body: e.response_body
+  }
+  ErrorReporter.report(e, context: error_context)
+end
+```
 
-#### ActionUrl
+## Rails integration
 
-When a user clicks on a notification in MagicBell's widget, the widget redirects the user to the first URL the body of the email notification. We call this URL the `ActionUrl`.
+If you've existing ActionMailer email notifications in your Rails app and prefer to not spend time migrating to MagicBell's API, you can blind copy your ActionMailer email notifications to MagicBell. MagicBell will create in-app notifications from email notifications blind copied to it.
 
-If you wish to redirect users to a different URL instead, set a custom `ActionUrl` in your mailers
+Call the `ring_the_magicbell` method in your action mailers like in the example below
 
 ```ruby
 class NotificationMailer < ActionMailer::Base
+  # The ring_the_magicbell method will bcc your email notifications to your MagicBell project's BCC email address
+  #
+  # Upon receiving a blind copied email notification, magicbell.io will automatically create an in-app notification for the user
   ring_the_magicbell
 
-  def new_comment(comment)
+  # This is an email notification in your app
+  def new_comment
     # ...
-    magicbell_notification_action_url("https://myapp.com/comments/#{comment.id}")
+  end
+
+  # This is another email notification in your app
+  def mentioned
     # ...
   end
 end
 ```
 
-#### Title
+The gem will automatically pick your MagicBell project's BCC email from the `MAGICBELL_BCC_EMAIL` environment variable. Alternatively, provide your MagicBell project's BCC email address in an initializer
 
-We use the subject of the email notification as a notification's title. If this behaviour isn't sutiable for your app, you can set a custom title in your mailers
+```
+vim config/initializers/magicbell.rb
+```
+
+```ruby
+# config/initializers/magicbell.rb
+
+MagicBell.configure do |config|
+  config.api_key = "your_magicbell_api_key"
+  config.api_secret = "your_magicbell_api_secret"
+  config.bcc_email = "your_magicbell_bcc_email@ring.magicbell.io"
+end
+```
+
+The BCC email address is available in the "Settings" section in your MagicBell dashboard.
+
+### Customize Action URL
+
+When a user clicks on a notification in MagicBell's Notification Inbox, the Notification Inbox redirects the user to the first URL the body of the email notification. This URL is called the `action_url`.
+
+If you wish to redirect users to a different URL instead, provide an `action_url` in your mailers
 
 ```ruby
 class NotificationMailer < ActionMailer::Base
@@ -139,15 +215,15 @@ class NotificationMailer < ActionMailer::Base
 
   def new_comment(comment)
     # ...
-    magicbell_notification_title("Richard commented on your post Drive to Lake Tahoe")
+    magicbell_notification_action_url("https://myapp.com/comments/#{comment.id}")
     # ...
   end
 end
 ```
 
-#### Metadata
+### Customize Notification Title
 
-Its possible to attach custom metadata to every notification. Say you wish to attach a comment's id to a new comment notification, here's how it can be done
+The Notification inbox will use the subject of the email notification as a notification's title. If this behaviour isn't sutiable for your app, provide a title in your mailers
 
 ```ruby
 class NotificationMailer < ActionMailer::Base
@@ -155,63 +231,31 @@ class NotificationMailer < ActionMailer::Base
 
   def new_comment(comment)
     # ...
-    magicbell_notification_metadata(comment_id: comment.id)
+    magicbell_notification_title("Richard posted a new comment")
     # ...
   end
 end
 ```
 
-You can later use this metadata to customize the behaviour of MagicBell's widget.
+## HMAC Authentication
 
-#### Customize widget behaviour
+### Calculate HMAC
 
-When a user clicks on a notification in MagicBell's widget, the widget redirects the user to the notification's `ActionUrl`. If this behaviour isn't suitable for your app (if your app is a Single Page Application for example), you can customize it.
-
-When initializing the widget, pass a `onNotificationClick` callback to customize the widget's behaviour
-
-```javascript
-function initializeMagicBell() {
-  MagicBell.initialize({
-    target: document.getElementById('magicbell_notifications'),
-    projectId: "<%= MagicBell.project_id %>",
-    apiKey: "<%= MagicBell.api_key %>",
-    userEmail: <%= current_user.email %>,
-    userKey: "<%= MagicBell.user_key(current_user.email) %>",
-    onNotificationClick: function (notification) {
-      // openComment is a function that you've defined in your app's javascript to open
-      // and display a specific comment to the user
-      openComment(notification.meta_data.comment_id)
-    }
-  });
-}
+```
+user_email = "joe@example.com"
+hmac = MagicBell.hmac(user_email)
 ```
 
+See https://developer.magicbell.io/docs/turn-on-hmac-authentication for more information on turning on HMAC Authentication for your MagicBell Project
 
-## Managing notifications
+## API docs
 
-### Creating a notification
+Please visit our website https://magicbell.io and our API docs https://developer.magicbell.io for more information MagicBell's embeddable notification inbox and MagicBell's REST API
 
-You can create notifications for users. Once `MagicBell` is configured, you can
-call `create_notification` method to create a notification for a given project.
+## Contact Us
 
-```
-params = {
-  to: "user@example.com",
-  title: "Your download is ready",
-  content: "Zip file to download is here",
-  action_url: "https://example.com/notifications/1"
-}
+Have a query or hit upon a problem? Create a post in our Developer Community https://community.magicbell.io or contact us at hello@magicbell.io
 
-client = MagicBell::Client.new()
-client.create_notification(params)
 ```
 
-The response will be a Faraday response object, and methods like `status` and
-`body` will be available for further inspection.
-
-
-If you'd like us to add more callbacks to the widget, reach out to us at hana@magicbell.io
-
-## Documentation
-
-Visit our [Docs Site](https://docs.magicbell.io) for more information on MagicBell, MagicBell's widget and Advanced Features.
+```

data/Rakefile

@@ -25,3 +25,17 @@ Rake::TestTask.new(:test) do |t|
 end
 
 task default: :test
+
+# @example
+#   GEM_HOST_API_KEY="our_rubygems_api_key" bundle exec rake publish_to_rubygems
+task :publish_to_rubygems do
+  `gem build magicbell.gemspec`
+  require_relative "lib/magicbell"
+  `gem push magicbell-#{MagicBell::VERSION}.gem`
+end
+
+task :console do
+  require_relative "lib/magicbell"
+  require "pry"
+  binding.pry
+end

data/lib/magicbell.rb

@@ -1,11 +1,27 @@
+require 'forwardable'
+
+require "openssl"
+require "base64"
+
 require "magicbell/config"
-require "magicbell/hmac"
-require "magicbell/user"
-require "magicbell/railtie" if defined?(Rails)
-require "magicbell/client"
 
-require 'forwardable'
+require "httparty"
+require "magicbell/api_operations"
+require "magicbell/client"
+require "magicbell/api_resource"
+require "magicbell/singleton_api_resource"
+require "magicbell/api_resource_collection"
+require "magicbell/api_resources/notification"
+require "magicbell/api_resources/user"
+require "magicbell/api_resources/user_notification"
+require "magicbell/api_resources/user_notifications"
+require "magicbell/api_resources/user_notification_read"
+require "magicbell/api_resources/user_notification_unread"
+require "magicbell/api_resources/user_notifications_read"
+require "magicbell/api_resources/user_notifications_seen"
+require "magicbell/api_resources/user_notification_preferences"
 
+require "magicbell/railtie" if defined?(Rails)
 
 module MagicBell
   WIDGET_JAVASCRIPT_URL = "https://assets.magicbell.io/widget.magicbell.js"
@@ -14,7 +30,10 @@ module MagicBell
   class << self
     extend Forwardable
 
-    def_delegators :@config, :api_key, :api_secret, :project_id, :magic_address, :api_host
+    def_delegators :config, :api_key,
+                            :api_secret,
+                            :bcc_email,
+                            :api_host
 
     def configure
       yield(config)
@@ -25,19 +44,28 @@ module MagicBell
     end
 
     def reset_config
-      @config = nil
+      @config = Config.new
     end
 
-    def project_specific_headers
+    def authentication_headers
       {
-        'X-MAGICBELL-API-KEY' => config.api_key,
-        'X-MAGICBELL-API-SECRET' => config.api_secret
+        "X-MAGICBELL-API-KEY" => api_key,
+        "X-MAGICBELL-API-SECRET" => api_secret
       }
     end
 
     # Calculate HMAC for user's email
-    def user_key(user_email)
-      MagicBell::HMAC.calculate(user_email, MagicBell.api_secret)
+    def hmac(message)
+      digest = sha256_digest
+      secret = api_secret
+
+      Base64.encode64(OpenSSL::HMAC.digest(digest, secret, message)).strip
+    end
+
+    private
+
+    def sha256_digest
+      OpenSSL::Digest::Digest.new('sha256')
     end
   end
 end

data/lib/magicbell/action_mailer_extension.rb

@@ -8,7 +8,7 @@ module MagicBell
 
     module ClassMethods
       def ring_the_magicbell
-        default bcc: MagicBell.magic_address
+        default bcc: MagicBell.bcc_email
       end
     end
 

data/lib/magicbell/api_operations.rb

@@ -0,0 +1,45 @@
+module MagicBell
+  module ApiOperations
+    def get(url, options = {})
+      defaults = { headers: default_headers }
+      response = HTTParty.get(url, options.merge(defaults))
+      raise_http_error_unless_2xx_response(response)
+
+      response
+    end
+
+    def post(url, options = {})
+      defaults = { headers: default_headers }
+      response = HTTParty.post(url, options.merge(defaults))
+      raise_http_error_unless_2xx_response(response)
+
+      response
+    end
+
+    def put(url, options = {})
+      defaults = { headers: default_headers }
+      response = HTTParty.put(url, options.merge(defaults))
+      raise_http_error_unless_2xx_response(response)
+
+      response
+    end
+
+    protected
+
+    def default_headers
+      authentication_headers.merge({ "Content-Type" => "application/json", "Accept"=> "application/json" })
+    end
+
+    private
+
+    def raise_http_error_unless_2xx_response(response)
+      return if response.success?
+
+      e = MagicBell::Client::HTTPError.new
+      e.response_status = response.code
+      e.response_headers = response.headers.to_h
+      e.response_body = response.body
+      raise e
+    end
+  end
+end

data/lib/magicbell/api_resource.rb

@@ -0,0 +1,126 @@
+require "active_support/inflector"
+require "active_support/core_ext/object/blank"
+require "json"
+
+module MagicBell
+  class ApiResource
+    class << self
+      def create(client, attributes = {})
+        new(client, attributes).create
+      end
+
+      def find(client, id)
+        api_resource = new(client, "id" => id)
+        api_resource.retrieve
+        api_resource
+      end
+
+      def name
+        to_s.demodulize.underscore
+      end
+
+      def create_path
+        "/#{name}s"
+      end
+
+      def create_url
+        MagicBell.api_host + create_path
+      end
+    end
+
+    attr_reader :id
+
+    def initialize(client, attributes = {})
+      @client = client
+      @attributes = attributes
+
+      @id = @attributes["id"]
+      @retrieved = true if @id
+    end
+
+    def attributes
+      retrieve_unless_retrieved
+      @attributes
+    end
+    alias_method :to_h, :attributes
+
+    def attribute(attribute_name)
+      attributes[attribute_name]
+    end
+
+    def retrieve
+      response = @client.get(url)
+      parse_response(response)
+
+      self
+    end
+
+    def name
+      self.class.name
+    end
+
+    def create_url
+      MagicBell.api_host + create_path
+    end
+
+    def create_path
+      "/#{name}s"
+    end
+
+    def url
+      MagicBell.api_host + path
+    end
+
+    def path
+      "/#{name}s/#{id}"
+    end
+
+    def create
+      response = @client.post(
+        create_url,
+        body: { name => attributes }.to_json,
+        headers: extra_headers
+      )
+      parse_response(response)
+
+      self
+    end
+
+    def update(new_attributes = {})
+      response = @client.put(
+        url,
+        body: new_attributes.to_json,
+        headers: extra_headers
+      )
+      parse_response(response)
+
+      self
+    end
+
+    protected
+
+    def extra_headers
+      {}
+    end
+
+    private
+
+    attr_reader :response,
+                :response_hash
+    
+    def retrieve_unless_retrieved
+      return unless id # Never retrieve a new unsaved resource
+      return if @retrieved
+      retrieve
+    end
+
+    def parse_response(response)
+      @response = response
+      unless response.body.blank?
+        @response_hash = JSON.parse(@response.body)
+        @attributes = @response_hash[name]
+      end
+      @retrieved = true
+    end
+  end
+end

data/lib/magicbell/api_resource_collection.rb

@@ -0,0 +1,89 @@
+module MagicBell
+  class ApiResourceCollection
+    def initialize(client, query_params = {})
+      @client = client
+      @query_params = query_params
+      @retrieved = false
+    end
+
+    # @todo Add examples
+    def retrieve
+      @response = @client.get(
+        url,
+        query: @query_params
+      )
+      @response_hash = JSON.parse(response.body)
+      @resources = response_hash[name].map { |resource_attributes| resource_class.new(@client, resource_attributes) }
+      @retrieved = true
+
+      self
+    end
+
+    def to_a
+      resources
+    end
+
+    def first
+      resources.first
+    end
+
+    def url
+      MagicBell.api_host + path
+    end
+
+    def authentication_headers
+      MagicBell.authentication_headers
+    end
+
+    def each(&block)
+      resources.each(&block)
+    end
+
+    def each_page
+      current_page = self
+      loop do
+        yield(current_page)
+        break if current_page.last_page?
+        current_page = current_page.next_page
+      end
+    end
+
+    def last_page?
+      current_page == total_pages
+    end
+
+    def next_page
+      self.class.new(@client, page: current_page + 1, per_page: per_page)
+    end
+
+    def current_page
+      retrieve_unless_retrieved
+      response_hash["current_page"]
+    end
+
+    def total_pages
+      retrieve_unless_retrieved
+      response_hash["total_pages"]
+    end
+
+    def per_page
+      retrieve_unless_retrieved
+      response_hash["per_page"]
+    end
+
+    private
+
+    attr_reader :response,
+                :response_hash
+    
+    def resources
+      retrieve_unless_retrieved
+      return @resources
+    end
+    
+    def retrieve_unless_retrieved
+      return if @retrieved
+      retrieve
+    end
+  end
+end

data/lib/magicbell/api_resources/notification.rb

@@ -0,0 +1,4 @@
+module MagicBell
+  class Notification < ApiResource
+  end
+end

data/lib/magicbell/api_resources/user.rb

@@ -0,0 +1,50 @@
+module MagicBell
+  class User < ApiResource
+    include ApiOperations
+
+    attr_reader :email
+
+    def initialize(client, attributes)
+      @client = client
+      @email = attributes["email"]
+      super(client, attributes)
+    end
+
+    def notifications(query_params = {})
+      client = self
+      MagicBell::UserNotifications.new(client, query_params)
+    end
+
+    def find_notification(notification_id)
+      client = self
+      MagicBell::UserNotification.find(client, notification_id)
+    end
+
+    def mark_all_notifications_as_read
+      client = self
+      MagicBell::UserNotificationsRead.new(client).create
+    end
+
+    def mark_all_notifications_as_seen
+      client = self
+      MagicBell::UserNotificationsSeen.new(client).create
+    end
+
+    def notification_preferences
+      client = self
+      MagicBell::UserNotificationPreferences.new(client)
+    end
+
+    def path
+      if id
+        self.class.path + "/#{id}"
+      elsif email
+        self.class.path + "/email:#{email}"
+      end
+    end
+
+    def authentication_headers
+      MagicBell.authentication_headers.merge("X-MAGICBELL-USER-EMAIL" => email)
+    end
+  end
+end

data/lib/magicbell/api_resources/user_notification.rb

@@ -0,0 +1,21 @@
+module MagicBell
+  class UserNotification < ApiResource
+    class << self
+      def path
+        "/notifications"
+      end
+    end
+
+    def path
+      "/notifications/#{id}"
+    end
+
+    def mark_as_read
+      UserNotificationRead.new(@client, "user_notification" => self).create
+    end
+
+    def mark_as_unread
+      UserNotificationUnread.new(@client, "user_notification" => self).create
+    end
+  end
+end

data/lib/magicbell/api_resources/user_notification_preferences.rb

@@ -0,0 +1,11 @@
+module MagicBell
+  class UserNotificationPreferences < ApiResource
+    def name
+      "notification_preferences"
+    end
+
+    def path
+      "/notification_preferences"
+    end
+  end
+end

data/lib/magicbell/api_resources/user_notification_read.rb

@@ -0,0 +1,14 @@
+module MagicBell
+  class UserNotificationRead < SingletonApiResource
+    attr_reader :user_notification
+
+    def initialize(client, attributes)
+      @user_notification = attributes.delete("user_notification")
+      super(client, attributes)
+    end
+
+    def path
+      user_notification.path + "/read"
+    end
+  end
+end

data/lib/magicbell/api_resources/user_notification_unread.rb

@@ -0,0 +1,14 @@
+module MagicBell
+  class UserNotificationUnread < SingletonApiResource
+    attr_reader :user_notification
+
+    def initialize(client, attributes)
+      @user_notification = attributes.delete("user_notification")
+      super(client, attributes)
+    end
+
+    def path
+      user_notification.path + "/unread"
+    end
+  end
+end

data/lib/magicbell/api_resources/user_notifications.rb

@@ -0,0 +1,15 @@
+module MagicBell
+  class UserNotifications < ApiResourceCollection
+    def name
+      "notifications"
+    end
+
+    def path
+      "/notifications"
+    end
+
+    def resource_class
+      MagicBell::UserNotification
+    end
+  end
+end

data/lib/magicbell/api_resources/user_notifications_read.rb

@@ -0,0 +1,7 @@
+module MagicBell
+  class UserNotificationsRead < SingletonApiResource
+    def path
+      "/notifications/read"
+    end
+  end
+end

data/lib/magicbell/api_resources/user_notifications_seen.rb

@@ -0,0 +1,7 @@
+module MagicBell
+  class UserNotificationsSeen < SingletonApiResource
+    def path
+      "/notifications/seen"
+    end
+  end
+end

data/lib/magicbell/client.rb

@@ -1,13 +1,28 @@
-require "magicbell/client/notifications"
-
 module MagicBell
   class Client
-    include MagicBell::Client::Notifications
+    class HTTPError < StandardError
+      attr_accessor :response_status,
+                    :response_headers,
+                    :response_body
+    end
+
+    include ApiOperations
+
+    def create_notification(notification_attributes)
+      MagicBell::Notification.create(self, notification_attributes)
+    end
+
+    # def user(user_id)
+    #   MagicBell::User.find(user_id)
+    # end
+
+    def user_with_email(email)
+      client = self
+      MagicBell::User.new(client, "email" => email)
+    end
 
-    # Returns an authenticated connection object which can be
-    # used to make requests
-    def connection
-      @connection ||= Faraday.new(url: MagicBell.api_host)
+    def authentication_headers
+      MagicBell.authentication_headers
     end
   end
 end

data/lib/magicbell/config.rb

@@ -1,13 +1,28 @@
 module MagicBell
   class Config
-    attr_accessor :api_key
-    attr_accessor :api_secret
-    attr_accessor :project_id
-    attr_accessor :magic_address
-    attr_accessor :api_host
+    attr_writer :api_key
+    attr_writer :api_secret
+    attr_writer :bcc_email
+    attr_writer :api_host
 
     def initialize
       @api_host = "https://api.magicbell.io"
     end
+
+    def api_key
+      @api_key || ENV["MAGICBELL_API_KEY"]
+    end
+
+    def api_secret
+      @api_secret || ENV["MAGICBELL_API_SECRET"]
+    end
+
+    def bcc_email
+      @bcc_email || ENV["MAGICBELL_BCC_EMAIL"]
+    end
+
+    def api_host
+      @api_host || ENV["MAGICBELL_API_HOST"] || "https://api.magicbell.io"
+    end
   end
 end

data/lib/magicbell/singleton_api_resource.rb

@@ -0,0 +1,7 @@
+module MagicBell
+  class SingletonApiResource < ApiResource
+    def create_path
+      path
+    end
+  end
+end

data/lib/magicbell/version.rb

@@ -1,3 +1,3 @@
 module MagicBell
-  VERSION = '0.2.0'
+  VERSION = '1.0.3'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: magicbell
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.0.3
 platform: ruby
 authors:
 - Hana Mohan
@@ -9,10 +9,10 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-04-24 00:00:00.000000000 Z
+date: 2021-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: httparty
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -26,7 +26,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -40,7 +40,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rails
+  name: actionmailer
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -67,6 +67,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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: 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'
 description: Notifications like never before!
 email:
 - hana@magicbell.io
@@ -80,12 +122,22 @@ files:
 - Rakefile
 - lib/magicbell.rb
 - lib/magicbell/action_mailer_extension.rb
+- lib/magicbell/api_operations.rb
+- lib/magicbell/api_resource.rb
+- lib/magicbell/api_resource_collection.rb
+- lib/magicbell/api_resources/notification.rb
+- lib/magicbell/api_resources/user.rb
+- lib/magicbell/api_resources/user_notification.rb
+- lib/magicbell/api_resources/user_notification_preferences.rb
+- lib/magicbell/api_resources/user_notification_read.rb
+- lib/magicbell/api_resources/user_notification_unread.rb
+- lib/magicbell/api_resources/user_notifications.rb
+- lib/magicbell/api_resources/user_notifications_read.rb
+- lib/magicbell/api_resources/user_notifications_seen.rb
 - lib/magicbell/client.rb
-- lib/magicbell/client/notifications.rb
 - lib/magicbell/config.rb
-- lib/magicbell/hmac.rb
 - lib/magicbell/railtie.rb
-- lib/magicbell/user.rb
+- lib/magicbell/singleton_api_resource.rb
 - lib/magicbell/version.rb
 homepage: https://magicbell.io
 licenses:
@@ -106,7 +158,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: Ruby wrapper for MagicBell.io

data/lib/magicbell/client/notifications.rb

@@ -1,20 +0,0 @@
-module MagicBell
-  class Client
-    module Notifications
-      # Creates a notification for a given project
-      #
-      # @param to [String] Email of a user for this notification
-      # @param title [String] Title of the notification
-      # @param content [String] Content of the notification
-      # @param action_url [String] Url to redirect to from widget
-      def create_notification(to, title, content, action_url)
-        params = {to: to, title: title, content: content, action_url: action_url}
-
-        connection.post("/notifications.json") do |req|
-          req.headers = {"X-MAGICBELL-API-SECRET" => MagicBell.api_secret}
-          req.body = {notification: params}
-        end
-      end
-    end
-  end
-end

data/lib/magicbell/hmac.rb

@@ -1,14 +0,0 @@
-require "openssl"
-require "base64"
-
-module MagicBell
-  module HMAC
-    class << self
-      def calculate(message)
-        secret = MagicBell.api_secret
-        digest = OpenSSL::Digest::Digest.new('sha256')
-        Base64.encode64(OpenSSL::HMAC.digest(digest, secret, message)).strip
-      end
-    end
-  end
-end

data/lib/magicbell/user.rb

@@ -1,41 +0,0 @@
-require 'faraday'
-require 'json'
-
-module MagicBell
-  class User
-
-    attr_accessor :email
-    attr_accessor :preferences
-    
-    def initialize(attributes)
-      @attributes = attributes
-      @email = @attributes[:email]
-      @conn = Faraday.new({
-        url: MagicBell.api_host, 
-        headers: MagicBell.project_specific_headers.merge(
-          'X-MAGICBELL-USER-EMAIL' => @email
-        )
-      })
-    end
-
-    def notifications
-      response = @conn.get "/notifications.json"
-      JSON.parse(response.body)["notifications"]
-    end
-
-    def hmac_signature
-      MagicBell::HMAC.calculate @email
-    end
-
-    def notification_preferences
-      response = @conn.get "/notification_preferences.json"
-      JSON.parse(response.body)["notification_preferences"]
-    end
-    
-    def notification_preferences=(preferences)
-       @conn.put "/notification_preferences.json", 
-                    {notification_preferences: preferences}
-    end
-    
-  end
-end