notify_user 0.0.1 → 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6ccbda4d4f6f0bd85a37c2e9295789c8c3c28844
+  data.tar.gz: f8f67249b41082e9af5dc4686bb3f85639360507
+SHA512:
+  metadata.gz: b9258b901edd1eb111a33354aafc2aa668b7520587594fad58e03d5d887042836633cc620a8b49d167220ebb16cac1c18423c78d9d45d8fc9bbbf76d4d5eaf78
+  data.tar.gz: ae8fd4a46fde87ffe996adc8e42e63b667a5b0525ceb269205a76e437a17df21209ff5f7f8e59d1298f4eee57cec35738b0d3059b094aa80876808cf8712f42f

data/app/assets/javascripts/notify_user/notification.js

@@ -0,0 +1,7 @@
+$( document ).ready(function() {
+	$('.message').click(function(){
+		item = $(this).parent().parent();
+		item.addClass('read');
+			
+	});
+});

data/app/assets/stylesheets/notify_user/notify_user.css

@@ -0,0 +1,50 @@
+.unread a{
+  font-weight: bold;
+}
+.read a{
+  font-weight: normal;
+}
+#notifications_list{
+  margin: 0 auto;
+  width: 100%;
+  width: 720px;
+  color: #000;
+  font-family: arial;
+  font-size: 14px;
+  text-align: right;
+  padding: 5px;
+  text-align: center;
+}
+
+#notifications_list .inner{
+  margin-top: 10px;
+  border: 1px solid #dedede;
+  text-align: left;
+
+}
+#notifications_list a{
+  color: #454545;
+  text-decoration: none;
+}
+#notifications_list .item:hover a{
+  text-decoration: underline;
+}
+
+#notifications_list .title{
+  text-align: left;
+}
+
+#notifications_list .item{
+  padding: 20px 10px;
+  border-bottom: 1px solid #dedede;
+}
+#notifications_list .item.read{
+  background: #eaeaea;
+}
+#notifications_list .item .time_ago{
+  font-size: 12px;
+  text-align: right;
+}
+#notifications_list .mark_as_read{
+  text-align: right;
+}

data/app/controllers/notify_user/base_notifications_controller.rb

@@ -0,0 +1,144 @@
+class NotifyUser::BaseNotificationsController < ApplicationController
+
+  before_filter :authenticate!, :except => [:unauth_unsubscribe]
+
+  def index
+    @notifications = NotifyUser::BaseNotification.for_target(@user)
+                                                  .order("created_at DESC")
+                                                  .limit(30)
+                                                  .page(params[:page]).per(params[:per_page])
+
+    respond_to do |format|
+      format.html
+      format.json {render :json => @notifications, meta: { pagination: { per_page: @notifications.limit_value, total_pages: @notifications.total_pages, total_objects: @notifications.total_count } }}
+    end
+  end
+
+  def mark_read
+    @notifications = NotifyUser::BaseNotification.for_target(@user).where('id IN (?)', params[:ids])
+    @notifications.update_all(state: :read)
+    render json: @notifications
+  end
+
+  def mark_all
+    @notifications = NotifyUser::BaseNotification.for_target(@user).where('state IN (?)', ["pending","sent"])
+    @notifications.update_all(state: :read)
+    redirect_to notify_user_notifications_path  
+  end
+
+  def notifications_count
+    @notifications = NotifyUser::BaseNotification.for_target(@user).where('state IN (?)', ["sent"])
+    render json: {:count => @notifications.count}
+  end
+
+  #get 
+  def read
+    @notification = NotifyUser::BaseNotification.for_target(@user).where('id = ?', params[:id]).first
+    @notification.mark_as_read
+    redirect_logic(@notification)
+  end
+
+  def redirect_logic(notification)
+    render :text => "redirect setup goes here"
+  end
+
+  def unsubscribe
+    if params[:type]
+      unsubscribe_from(params[:type])
+      redirect_to notify_user_notifications_unsubscribe_path  
+    end
+    @unsubscribale_types = NotifyUser.unsubscribable_notifications
+    @unsubscribale_channels = NotifyUser::BaseNotification.channels
+  end
+
+  #endpoint for accessing subscriptions and their statuses
+  def subscriptions
+    update_subscriptions(params[:types]) if params[:types]
+    @types = build_notification_types
+    render :json => @types
+  end
+
+  def update_subscriptions(types)
+    types.each do |type|
+      unsubscribe = NotifyUser::Unsubscribe.has_unsubscribed_from(@user, type[:type])
+      if type[:status] == '0'
+        if unsubscribe.empty?
+          #if unsubscribe doesn't exist create it 
+          unsubscribe = NotifyUser::Unsubscribe.create(target: @user, type: type[:type])
+        end
+      else
+        subscribe_to(type[:type])
+      end
+    end 
+  end
+
+  def unauth_unsubscribe
+    if params[:token] && params[:type]
+      if NotifyUser::UserHash.confirm_hash(params[:token], params[:type])
+        user_hash = NotifyUser::UserHash.where(token: params[:token], type: params[:type]).first
+        @user = user_hash.target
+        unsubscribe = NotifyUser::Unsubscribe.create(target: @user, type: params[:type])
+        user_hash.deactivate
+        return render :text => "successfully unsubscribed from #{params[:type]} notifications"
+      else
+        return render :text => "invalid token"
+      end
+    end
+    return render :text => "Something went wrong please try again later"
+  end
+
+  def subscribe
+    subscribe_to(params[:type]) if params[:type]
+    redirect_to notify_user_notifications_unsubscribe_path
+  end
+
+  protected
+
+  def default_serializer_options
+    {
+      each_serializer: NotifyUser::NotificationSerializer,
+      template_renderer: self
+    }
+  end
+
+  def authenticate!
+    method(NotifyUser.authentication_method).call
+    @user = method(NotifyUser.current_user_method).call
+  end
+
+  private
+  def build_notification_types()
+    #dirty way to build a json hash with pagination
+    types = {:subscriptions => []}
+
+    notification_types = NotifyUser.unsubscribable_notifications
+
+    #iterates over channels
+    NotifyUser::BaseNotification.channels.each do |type, options|
+        channel = (type.to_s + "_channel").camelize.constantize
+        types[:subscriptions] << {type: type, description: channel.default_options[:description],
+          status: NotifyUser::Unsubscribe.has_unsubscribed_from(@user, type).empty?}
+    end 
+
+    #iterates over type
+    notification_types.each do |type|
+        types[:subscriptions] << {type: type, description: type.constantize.description,
+          status: NotifyUser::Unsubscribe.has_unsubscribed_from(@user, type).empty?}
+    end
+    return types
+  end
+
+  def unsubscribe_from(type)
+      unsubscribe = NotifyUser::Unsubscribe.new(target: @user, type: type)
+      if unsubscribe.save
+        flash[:message] = "successfully unsubscribed from #{type} notifications"
+      else
+        flash[:message] = "Please try again"
+      end
+  end
+
+  def subscribe_to(type)
+    NotifyUser::Unsubscribe.unsubscribe(@user,type)
+    flash[:message] = "successfully subscribed to #{type} notifications"
+  end
+end

data/app/controllers/notify_user/notifications_controller.rb

@@ -1,33 +1,8 @@
-class NotifyUser::NotificationsController < ApplicationController
-
-  before_filter :authenticate!
-
-  def index
-    @notifications = NotifyUser::BaseNotification.for_target(@user)
-                                                  .order("created_at DESC")
-                                                  .limit(30)
-                                                  .page(params[:page])
-
-    render json: @notifications
-  end
-
-  def mark_read
-    @notifications = NotifyUser::BaseNotification.for_target(@user).where('id IN (?)', params[:ids])
-    @notifications.update_all(state: :read)
-    render json: @notifications
-  end
-
-  protected
-
-  def default_serializer_options
-    {
-      each_serializer: NotifyUser::NotificationSerializer,
-      template_renderer: self
-    }
-  end
-
-  def authenticate!
-    method(NotifyUser.authentication_method).call
-    @user = method(NotifyUser.current_user_method).call
-  end
+class NotifyUser::NotificationsController < NotifyUser::BaseNotificationsController 
+	def redirect_logic(notification)
+		render :text => "set redirect logic in notify_user/notifications_controller.rb"
+		#notification redirect logic goes here
+		#property = Property.find(@notification.params[:property_id])
+		#redirect_to property_url(@property)
+	end
 end

data/app/helpers/notify_user/application_helper.rb

@@ -1,4 +1,13 @@
 module NotifyUser
   module ApplicationHelper
+  	def unsubscribe_link(notification, text)
+  		user_hash =  notification.generate_unsubscribe_hash
+  		html = link_to(text, notify_user_notifications_unauth_unsubscribe_url(:type => notification.type, :token => user_hash.token))
+  		return html.to_s.html_safe
+  	end
+
+  	def is_unsubscribeable?(notification)
+  		return NotifyUser.unsubscribable_notifications.include? notification.type
+  	end
   end
 end

data/app/mailers/notify_user/notification_mailer.rb

@@ -1,5 +1,6 @@
 module NotifyUser
   class NotificationMailer < ActionMailer::Base
+    helper NotifyUser::ApplicationHelper
 
     layout "notify_user/layouts/action_mailer"
   
@@ -15,6 +16,7 @@ module NotifyUser
 
     def aggregate_notifications_email(notifications, options)
       @notifications = notifications
+      @notification = notifications.first
 
       mail to: @notifications.first.target.email,
            template_name: "aggregate_notification",

data/app/models/notify_user/apns.rb

@@ -0,0 +1,37 @@
+module NotifyUser
+  class Apns
+    SYMBOL_NAMES_SIZE = 10 
+    PAYLOAD_LIMIT = 255
+
+    #sends push notification
+    def self.push_notification(notification)
+      #calculates the bytes already used 
+      used_space = SYMBOL_NAMES_SIZE + notification.id.size + notification.created_at.to_time.to_i.size +
+                    notification.type.size
+                    
+      used_space += notification.params[:action_id].size if notification.params[:action_id]               
+
+      space_allowance = PAYLOAD_LIMIT - used_space   
+
+      payload = {
+        :alias => notification.target_id,
+        :aps => {alert: notification.mobile_message(space_allowance), badge: 1},
+        :n_data => {
+          '#' => notification.id,     
+          t: notification.created_at.to_time.to_i, 
+          '?' => notification.type
+        }
+      }
+      payload[:n_data]['!'] = notification.params[:action_id] if notification.params[:action_id]
+
+      response = Urbanairship.push(payload)
+        if response.success?
+          puts "Push notification sent successfully."
+          return true
+        else
+          puts "Push notification failed."
+          return false
+        end    
+    end
+  end
+end

data/app/models/notify_user/base_notification.rb

@@ -3,6 +3,7 @@ require 'sidekiq'
 
 module NotifyUser
   class BaseNotification < ActiveRecord::Base
+    include ActionView::Helpers::TextHelper
 
     if ActiveRecord::VERSION::MAJOR < 4
       attr_accessible :params, :target, :type, :state
@@ -11,8 +12,11 @@ module NotifyUser
     # Override point in case of collisions, plus keeps the table name tidy.
     self.table_name = "notify_user_notifications"
 
+    #checks if user has unsubscribed from this notif type
+    validate :unsubscribed_validation
+
     # Params for creating the notification message.
-    serialize :params, Hash
+    # serialize :params, Hash
 
     # The user to send the notification to
     belongs_to :target, polymorphic: true
@@ -46,8 +50,29 @@ module NotifyUser
       end
     end
 
-    ## Public Interface
+    def params
+      if super.nil?
+        {}
+      else
+        super.with_indifferent_access
+      end
+    end
+
+    def message
+      ActionView::Base.new(
+             Rails.configuration.paths["app/views"]).render(
+             :template => self.class.views[:mobile_sdk][:template_path].call(self), :formats => [:html], 
+             :locals => { :params => self.params}, :layout => false)
+    end
 
+    def mobile_message(length=115)
+      truncate(ActionView::Base.new(
+             Rails.configuration.paths["app/views"]).render(
+             :template => self.class.views[:mobile_sdk][:template_path].call(self), :formats => [:html], 
+             :locals => { :params => self.params}, :layout => false), :length => length)
+    end
+
+    ## Public Interface
     def to(user)
       self.target = user
       self
@@ -59,7 +84,7 @@ module NotifyUser
     end
 
     def notify!
-      save!
+      save
 
       # Bang version of 'notify' ignores aggregation
       self.deliver!
@@ -68,29 +93,35 @@ module NotifyUser
     # Send any Emails/SMS/APNS
     def notify
 
-      save!
-
-      if self.class.aggregate_per
-
-        # Schedule to send later if there aren't already any scheduled.
-        # Otherwise ignore, as the already-scheduled aggregate job will pick this one up when it runs.
-        if not aggregation_pending?
+      save
 
-          # Send in X minutes, along with any others created in the intervening times.
-          self.class.delay_for(self.class.aggregate_per).notify_aggregated(self.id)
+      #if aggregation is false bypass aggregation completely
+      self.channels.each do |channel_name, options|
+        if(options[:aggregate_per] == false)
+          self.class.delay.deliver_notification_channel(self.id, channel_name)    
+        else
+          if not aggregation_pending?
+            self.class.delay_for(options[:aggregate_per] || self.aggregate_per).notify_aggregated_channel(self.id, channel_name)
+          end
         end
-      else
-        # No aggregation, send immediately.
-        self.deliver
       end
 
     end
 
+    def generate_unsubscribe_hash
+      #check if a hash already exists for that user otherwise create a new one
+      return NotifyUser::UserHash.where(target_id: self.target.id).where(target_type: self.target.class.base_class).where(type: self.type).where(active: true).first || NotifyUser::UserHash.create(target: self.target, type: self.type, active: true)
+    end
+
+    ## Notification description
+    class_attribute :description
+    self.description = ""
+
     ## Channels
 
     mattr_accessor :channels
     @@channels = {
-      action_mailer: {},
+      action_mailer: {description: 'Email notifications'}
     }
 
     # Not sure about this. The JSON and web feeds don't fit into channels, because nothing is broadcast through
@@ -109,14 +140,14 @@ module NotifyUser
 
     ## Aggregation
 
-    mattr_accessor :aggregate_per
-    @@aggregate_per = 1.minute
+    class_attribute :aggregate_per
+    self.aggregate_per = 1.minute
 
     ## Sending
 
     def self.for_target(target)
       where(target_id: target.id)
-      .where(target_type: target.class.name)
+      .where(target_type: target.class.base_class)
     end
 
     def self.pending_aggregation_with(notification)
@@ -131,35 +162,88 @@ module NotifyUser
       return (self.class.pending_aggregation_with(self).where('id != ?', id).count > 0)
     end
 
-    def deliver
-      self.mark_as_sent
-      self.save
+    # def deliver
+    #   unless user_has_unsubscribed?
+    #     self.mark_as_sent
+    #     self.save
 
-      self.class.delay.deliver_channels(self.id)
-    end
+    #     self.class.delay.deliver_channels(self.id)
+    #   end
+    # end
 
     def deliver!
-      self.mark_as_sent
-      self.save
-      self.class.deliver_channels(self.id)
+      unless user_has_unsubscribed?
+        self.mark_as_sent
+        self.save
+        self.class.deliver_channels(self.id)
+      end
     end
 
     # Deliver a single notification across each channel.
     def self.deliver_channels(notification_id)
       notification = self.where(id: notification_id).first
       return unless notification
-
       self.channels.each do |channel_name, options|
-        channel = (channel_name.to_s + "_channel").camelize.constantize
-        channel.deliver(notification, options)
+        unless unsubscribed_from_channel?(notification.target, channel_name)
+          channel = (channel_name.to_s + "_channel").camelize.constantize
+          channel.deliver(notification, options)
+        end
       end
     end
 
     # Deliver multiple notifications across each channel as an aggregate message.
     def self.deliver_channels_aggregated(notifications)
       self.channels.each do |channel_name, options|
-        channel = (channel_name.to_s + "_channel").camelize.constantize
-        channel.deliver_aggregated(notifications, options)
+          if options[:aggregate_per] != false && !unsubscribed_from_channel?(notifications.first.target, channel_name)
+            channel = (channel_name.to_s + "_channel").camelize.constantize
+            channel.deliver_aggregated(notifications, options)
+          end
+      end
+    end
+
+    #deliver to specific channel methods
+
+    # Deliver a single notification to a specific channel.
+    def self.deliver_notification_channel(notification_id, channel_name)
+      notification = self.where(id: notification_id).first
+      return unless notification
+      channel_options = channels[channel_name.to_sym]
+
+      channel = (channel_name.to_s + "_channel").camelize.constantize
+      unless self.unsubscribed_from_channel?(notification.target, channel_name)
+        channel.deliver(notification, channel_options)
+      end
+    end
+
+    # Deliver a aggregated notifications to a specific channel.
+    def self.deliver_notifications_channel(notifications, channel_name)
+      channel_options = channels[channel_name.to_sym]
+      channel = (channel_name.to_s + "_channel").camelize.constantize
+
+      #check if user unsubsribed from channel type
+      unless self.unsubscribed_from_channel?(notifications.first.target, channel_name)
+        channel.deliver_aggregated(notifications, channel_options)
+      end
+    end
+
+    #notifies a single channel for aggregation
+    def self.notify_aggregated_channel(notification_id, channel_name)
+      notification = self.find(notification_id) # Raise an exception if not found.
+
+      # Find any pending notifications with the same type and target, which can all be sent in one message.
+      notifications = self.pending_aggregation_with(notification)
+      
+      notifications.map(&:mark_as_sent)
+      notifications.map(&:save)
+
+      return if notifications.empty?
+
+      if notifications.length == 1
+        # Despite waiting for more to aggregate, we only got one in the end.
+        self.deliver_notification_channel(notifications.first.id, channel_name)
+      else
+        # We got several notifications while waiting, send them aggregated.
+        self.deliver_notifications_channel(notifications, channel_name)
       end
     end
 
@@ -183,5 +267,25 @@ module NotifyUser
       end
     end
 
+    private
+    def unsubscribed_validation
+      errors.add(:target, (" has unsubscribed from this type")) if user_has_unsubscribed?   
+    end
+
+    def user_has_unsubscribed?
+      #return true if user has unsubscribed 
+      return true unless NotifyUser::Unsubscribe.has_unsubscribed_from(self.target, self.type).empty?  
+
+      return false 
+    end
+ 
+    def self.unsubscribed_from_channel?(user, type)
+      #return true if user has unsubscribed 
+      return true unless NotifyUser::Unsubscribe.has_unsubscribed_from(user, type).empty?  
+
+      return false 
+    end
+
+
   end
 end