dallal 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 53e11c8daaf54da4d759d04172b5e2ba5fcc4d1d
-  data.tar.gz: 69bb8738060d5c68b1ddc1c888a25aeaa873cbb2
+  metadata.gz: 48bb2a87abb110aaab509c6ebaf377f63260f7aa
+  data.tar.gz: 9ceaa80e8deabc46baa7c4ed0a688bbb5c0036c5
 SHA512:
-  metadata.gz: 5a30fb2af03e8d7e81ce72b2cb7286a147b5191a3eeadbe26dfebf1ca83db9e52c477ecf58a4bce0b29edc773fbd0248f66b71420576168e88ba92d1455702a4
-  data.tar.gz: 7ae52241acef4c1e0af8c716499ac5899f3a9e534ad2222176c8ec85786b07fd12af54784c7a1073e2573a25c980a304479c35356e2b7a906fb9b724ab73ee16
+  metadata.gz: 426f3fc734c51e3779d9a992de79fe1a6791b990445ebece635307d844ce57d744932930d690eed734ccf17b7b0babaa470347759871d3dd2952998bb3d9d92d
+  data.tar.gz: 9fcbf3ec632c534d11ae99416f8db2c8e8a321319b57dab4a7acc9da2cee0f8981fda62319fef5445da6204bae5077edb1354257612565a757177d0fc3c066b2

data/lib/dallal.rb

@@ -1,9 +1,10 @@
 require "dallal/engine" if defined?(Rails)
+require 'dallal/configuration'
 require 'dallal/notification'
 require 'dallal/notifiers/notifier'
 require 'dallal/events/events'
-require 'dallal/configuration'
 require 'dallal/events/event_publisher'
+require 'twilio-ruby'
 
 module Dallal
   extend Configuration

data/lib/dallal/configuration.rb

@@ -2,8 +2,9 @@ require 'ostruct'
 
 module Dallal
   module Configuration
-    CURRENT_ATTRS = [:user_class_name, :dallal_class_name,
-                     :enabled, :email_layout, :from_email, :from_name].freeze
+    CURRENT_ATTRS = [:user_class_name, :dallal_class_name, :enabled,
+                     :email_layout, :from_email, :from_name,
+                     :twilio_account_id, :twilio_auth_token, :sms_from].freeze
     DEPRECATED_ATTRS = [].freeze
     CONFIG_ATTRS = (CURRENT_ATTRS + DEPRECATED_ATTRS).freeze
 
@@ -42,12 +43,20 @@ module Dallal
 
       private
       def set_default_values
+        # App config
         self.user_class_name = 'User'
         self.dallal_class_name = 'Dallal'
         self.enabled = true
+
+        # Email config
         self.email_layout = 'mailer'
         self.from_email = 'foo@bar.xyz'
         self.from_name = 'just a name'
+
+        # SMS config
+        self.twilio_account_id = 'YOUR TWILIO ACCOUNT ID'
+        self.twilio_auth_token = 'TWILIO_AUTH_TOKEN'
+        self.sms_from = 'Sender phone number'
       end
     end
   end

data/lib/dallal/events/observer.rb

@@ -26,6 +26,7 @@ module Dallal
       def self.create_notification(id:, event:)
         # TODO This loops on all callbacks. Rethink this
         # method and implement it differently. Add listeners?
+        # Change callbacks data structure
         callbacks.each do |callback|
           next unless callback[:on].include?(event)
           obj = model_class.constantize.find(id)

data/lib/dallal/notification.rb

@@ -42,16 +42,16 @@ module Dallal
 
     def dispatch!
       validate!
-      @notifiers.each { |n| n.notify! }
+      @notifiers.each do |notifier|
+        # notifier.validate!
+        notifier.notify!
+      end
       @notifiers.each { |n| n.persist! } if persist?
     end
 
     private
     # TODO Implement this
-    # when target is nil throw error
-    # on email notification when template is nil throw error
-    # on sms notification when payload is nil throw an error
-    # on any other notifiers add a validation logic here
+    # Add validation logic here
     def validate!
       if false
         raise "You have not defined \'notify\' in \'with\' block for #{class_name} notifier"

data/lib/dallal/notifications/sms_notification.rb

@@ -2,10 +2,29 @@ require 'dallal/notifications/base_notification'
 module Dallal
   module Notifications
     class SmsNotification < BaseNotification
-      attr_reader :sms_payload
+      attr_reader :to
+      attr_reader :from
+      attr_reader :body
+
+      def initialize(notification, target)
+        super(notification, target)
+        @from = Dallal.configuration.sms_from
+      end
  
-      def payload payload
-        @sms_payload = payload
+      def template template
+        raise NotImplementedError
+      end
+
+      def message message
+        @body = message
+      end
+
+      def recipient recipient_number
+        @to = recipient_number
+      end
+
+      def to
+        @to || target.phone_number
       end
 
       def notifier

data/lib/dallal/notifiers/sms_notifier.rb

@@ -3,12 +3,28 @@ module Dallal
   module Notifiers
     class SmsNotifier < Notifier
 
-      def notify!
+      class << self
+        def client
+          @client ||= Twilio::REST::Client.new(
+            Dallal.configuration.twilio_account_id,
+            Dallal.configuration.twilio_auth_token)
+        end
       end
 
+      def notify!
+        client.messages.create(from: notification.from,
+                               to: notification.to,
+                               body: notification.body)
+      end
 
       def persist!
       end
+
+      def client
+        self.class.client
+      end
+
+      private
     end
   end
 end

data/lib/dallal/version.rb

@@ -1,7 +1,7 @@
 module Dallal
   MAJOR = 0
-  MINOR = 2
-  PATCH = 0
+  MINOR = 3
+  PATCH = 1
 
   VERSION = [MAJOR, MINOR, PATCH].compact.join(".")
 end

data/lib/generators/dallal/install/templates/dallal.rb

@@ -1,16 +1,20 @@
 Dallal.configure do |config|
   # Set the user class name of your app
-  config.user_class_name  = 'User'
+  # config.user_class_name  = 'User'
 
   # Set up user notification class name
-  config.dallal_class_name = 'Dallal'
+  # config.dallal_class_name = 'DallalNo'
 
-  # Enable / Disable notifications globaly
+  # Enable / Disable notifications globally
   config.enabled = true
 
-  # 
-  # config.available_notifications = [:email]
+  # Email config
+  config.email_layout = 'mailer'
+  config.from_email = 'info@yourdomain.com'
+  config.from_name = 'System Display Name'
 
-  # 
-  # config.auto_deliver = true
+  # Twulio SMS configuration
+  config.twilio_account_id = 'YOUR TWILIO ACCOUNT ID'
+  config.twilio_auth_token = 'YOUR TWILIO_AUTH_TOKEN'
+  config.sms_from = 'Your Twilio phone phone number'
 end

data/spec/dallal/configuration_spec.rb

@@ -45,7 +45,10 @@ describe Dallal::Configuration do
         enabled: true,
         email_layout: 'mailer',
         from_email: 'foo@bar.xyz',
-        from_name: 'just a name'
+        from_name: 'just a name',
+        twilio_account_id: 'YOUR TWILIO ACCOUNT ID',
+        twilio_auth_token: 'TWILIO_AUTH_TOKEN',
+        sms_from: 'Sender phone number',
       })
     end
   end

data/spec/dallal/events/event_subscriber_spec.rb

@@ -17,6 +17,7 @@ describe Dallal::Events::EventSubscriber do
   end
 
   context 'when a create event is broadcasted' do
+    # Failes randomly
     it 'creates a new instance and executes' do
       # save the user
       user.save!

data/spec/dallal/notification_spec.rb

@@ -27,7 +27,7 @@ describe Dallal::Notification do
       Dallal::Notification.new(event: :create, model_class: 'Post', opts: { a: 1 }, _object: @post)
     end
 
-    it 'should get the target(s) and call the block' do
+    it 'should get a single target and call the block' do
       executed = false
       subject.notify(@user) do
         executed = true
@@ -36,6 +36,17 @@ describe Dallal::Notification do
       expect(subject.targets).to eq [@user]
     end
 
+    it 'should get multiple target and call the block' do
+      executed = false
+      other = double("OtherUser")
+      subject.notify(@user, other) do
+        executed = true
+      end
+
+      expect(executed).to eq true
+      expect(subject.targets).to eq [@user, other]
+    end
+
     context 'notify with nested with block' do
       it 'calls with block' do
         executed = false
@@ -53,14 +64,18 @@ describe Dallal::Notification do
       end
 
       it 'evaluates correctly an sms block' do
+        subject.define_singleton_method(:post) {}
+        allow(subject).to receive(:post).and_return(@post)
         subject.notify(@user) do
           with :sms do
-            payload({ a:1, b: 2 })
+            message "Message #{post.user.email}"
+            recipient post.user.phone_number
           end
         end
         notifier = subject.notifiers.first
         expect(notifier).to be_a(Dallal::Notifiers::SmsNotifier)
-        expect(notifier.notification.sms_payload).to eq({a: 1, b: 2})
+        expect(notifier.notification.body).to eq("Message #{@post.user.email}")
+        expect(notifier.notification.to).to eq @post.user.phone_number
         expect(subject.targets).to eq([@user])
       end
 
@@ -101,14 +116,20 @@ describe Dallal::Notification do
       end
     end
 
-    context "multiple notifiers" do
+    context "multiple types" do
       it 'fills properties correctly' do
+        subject.define_singleton_method(:post) do
+          @post
+        end
+        allow(subject).to receive(:post).and_return(@post)
+
         subject.notify(@user) do
           with :email do
             template :email_template
           end
           with :sms do
-            payload a: 1, b: 2
+            message "Message #{post.user.email}"
+            recipient post.user.phone_number
           end
         end
         email_notifier = subject.notifiers.first
@@ -118,9 +139,41 @@ describe Dallal::Notification do
         expect(email_notifier).to be_a(Dallal::Notifiers::EmailNotifier)
         expect(email_notifier.notification.template_name).to eq :email_template
         expect(sms_notifier).to be_a(Dallal::Notifiers::SmsNotifier)
-        expect(sms_notifier.notification.sms_payload).to eq(a: 1, b: 2)
+        expect(sms_notifier.notification.body).to eq "Message #{@post.user.email}"
+        expect(sms_notifier.notification.to).to eq @post.user.phone_number
+      end
+    end
+
+    context "multiple #notify blocks" do
+      before do
+        subject.define_singleton_method(:post) do
+          @post
+        end
+        allow(subject).to receive(:post).and_return(@post)
       end
-   end
+      it 'evaluates multiple efinitions of notify' do
+        subject.notify(@user) do
+          with :email do
+            template :a_template
+          end
+        end
+
+        second_user = double("SecondUser")
+        subject.notify(second_user) do
+          with :email do
+            template :b_template
+          end
+        end
+
+        expect(subject.notifiers.size).to eq 2
+        first = subject.notifiers[0]
+        expect(first.notification.target).to eq @user
+        expect(first.notification.template_name).to eq :a_template
+        second = subject.notifiers[1]
+        expect(second.notification.target).to eq second_user
+        expect(second.notification.template_name).to eq :b_template
+      end
+    end
   end
 
   describe 'dispatch!' do
@@ -139,12 +192,86 @@ describe Dallal::Notification do
         subject.dispatch!
       end
     end
-    context 'single email notification' do
+    context 'single email notification with persistance' do
       pending
     end
+
+    context 'single sms notification' do
+      it 'send an sms notification' do
+        subject.notify(@user) do
+          with :sms do
+            message "a message"
+          end
+        end
+
+        expect(subject.notifiers.size).to eq 1
+        expect(subject.notifiers.first).to receive(:notify!)
+        expect(subject.notifiers.first).to_not receive(:persist!)
+
+        subject.dispatch!
+      end
+    end
+
+    context 'single sms notification with persistance' do
+      pending
+    end
+
     context 'multiple notifications' do
       pending
     end
+
+    context "multiple users to be notified" do
+      it 'sends an notification to each one of them' do
+        other = double("OtherUser")
+        subject.notify(@user, other) do
+          with :sms do
+            message 'a message'
+          end
+        end
+
+        expect(subject.notifiers.size).to eq 2
+        expect(subject.notifiers.first).to receive(:notify!)
+        expect(subject.notifiers.last).to receive(:notify!)
+        subject.dispatch!
+      end
+    end
+  end
+
+  describe "#with" do
+    pending
+  end
+
+  describe "#get_notifier" do
+    before do
+      subject.define_singleton_method(:post) {}
+      allow(subject).to receive(:post).and_return(@post)
+    end
+    context "sms notification" do
+      context "when recipient is defined" do
+        it 'creates a notification and return an sms notifier' do
+          blk = proc { message "a message"; recipient post.user }
+          notifier = subject.send(:get_notifier, :sms, @user, &blk)
+          expect(notifier).to be_a Dallal::Notifiers::SmsNotifier
+          notification = notifier.notification
+          expect(notification.target).to eq @user
+          expect(notification.body).to eq "a message"
+          expect(notification.to).to eq @post.user
+          expect(notification.from).to eq Dallal.configuration.sms_from
+        end
+      end
+      context "when recipient is not defined" do
+        it 'gets the number from target user' do
+          blk = proc { message "a message" }
+          notifier = subject.send(:get_notifier, :sms, @user, &blk)
+          expect(notifier).to be_a Dallal::Notifiers::SmsNotifier
+          notification = notifier.notification
+          expect(notification.target).to eq @user
+          expect(notification.body).to eq "a message"
+          expect(notification.to).to eq @post.user.phone_number
+          expect(notification.from).to eq Dallal.configuration.sms_from
+        end
+      end
+    end
   end
 
   describe 'persist?' do

data/spec/dallal/notifiers/notifier_spec.rb

@@ -4,6 +4,7 @@ describe Dallal::Notifiers::Notifier do
   let(:notification) { double("Notification") }
   subject { Dallal::Notifiers::Notifier.new(notification) }
   it { expect(subject).to be_a Dallal::AbstractInterface }
+  it { expect(subject.notification).to eq(notification) }
 
   describe "#persist!" do
     it 'should raise an error' do

data/spec/dallal/notifiers/sms_notifier_spec.rb

@@ -0,0 +1,26 @@
+require 'rails_helper'
+
+describe Dallal::Notifiers::SmsNotifier do
+  let(:notification) do
+    double("Notification", body: 'a message', from: '111', to: '222')
+  end
+  subject { Dallal::Notifiers::SmsNotifier.new(notification) }
+
+  it { expect(subject).to be_a(Dallal::Notifiers::Notifier) }
+
+  describe '.client' do
+    it 'should return a twillio clinet' do
+      client = subject.client
+      expect(client).to be_a Twilio::REST::Client
+    end
+  end
+
+  describe '#notify' do
+    it 'should create a message with twillio reset client' do
+      expect(subject.client).to receive_message_chain(:messages, :create).with(from: notification.from, to: notification.to, body: notification.body)
+      subject.notify!
+    end
+  end
+
+  describe '#persist'
+end