ama_layout 6.3.0.pre → 6.10.0.pre

data/lib/ama_layout/navigation_helper.rb

@@ -0,0 +1,31 @@
+module AmaLayout
+  module NavigationHelper
+    def navigation
+      return AmaLayout::Navigation.non_member unless member?
+      case
+      when _has_outstanding_balance?
+        AmaLayout::Navigation.member_with_outstanding_balance
+      when _in_renewal_late?
+        AmaLayout::Navigation.member_in_renewal_late
+      when _in_renewal?
+        AmaLayout::Navigation.member_in_renewal
+      else
+        AmaLayout::Navigation.member
+      end
+    end
+
+    private
+
+    def _in_renewal?
+      in_renewal
+    end
+
+    def _in_renewal_late?
+      status == "AL"
+    end
+
+    def _has_outstanding_balance?
+      has_outstanding_balance
+    end
+  end
+end

data/lib/ama_layout/notification.rb

@@ -0,0 +1,89 @@
+module AmaLayout
+  class Notification
+    include Draper::Decoratable
+
+    TYPES = %i[notice warning alert].freeze
+    DEFAULT_LIFESPAN = 1.year.freeze
+    FORMAT_VERSION = '1.0.0'.freeze
+
+    # NOTE: The following attributes are designed to be immutable - you need
+    # make a new instance to change them. The only mutable attribute is :active.
+    attr_reader :id, :type, :brand, :header, :content, :created_at, :lifespan,
+                :version
+    attr_accessor :active
+
+    def initialize(args = {})
+      args = args.with_indifferent_access
+      @id = args[:id]
+      @type = args.fetch(:type, :notice).to_sym
+      @brand = args[:brand]
+      @header = args.fetch(:header)
+      @content = args.fetch(:content)
+      @created_at = parse_time(args.fetch(:created_at))
+      @lifespan = parse_duration(args.fetch(:lifespan, DEFAULT_LIFESPAN))
+      @version = args.fetch(:version, FORMAT_VERSION)
+      self.active = args.fetch(:active)
+      invalid_type! if TYPES.exclude?(type)
+    end
+
+    def <=>(other)
+      created_at <=> other.created_at
+    end
+
+    def active?
+      active
+    end
+
+    def dismissed?
+      !active?
+    end
+
+    def dismiss!
+      self.active = false
+      dismissed?
+    end
+
+    def digest
+      Digest::SHA256.hexdigest(
+        "#{type}#{header}#{content}#{brand}#{version}"
+      )
+    end
+
+    def stale?
+      Time.current > created_at + lifespan
+    end
+
+    def to_h
+      # NOTE: We want the following keys to be strings to provide
+      # consistency with the underlying data store.
+      {
+        'type' => type.to_s,
+        'brand' => brand,
+        'header' => header,
+        'content' => content,
+        'created_at' => created_at.iso8601,
+        'active' => active,
+        'lifespan' => lifespan.to_i,
+        'version' => version
+      }
+    end
+
+    private
+
+    def invalid_type!
+      raise ArgumentError, "invalid notification type: #{type}"
+    end
+
+    def parse_time(time)
+      time.is_a?(String) ? Time.zone.parse(time) : time
+    end
+
+    def parse_duration(duration)
+      if duration.is_a?(ActiveSupport::Duration)
+        duration
+      else
+        duration.seconds
+      end
+    end
+  end
+end

data/lib/ama_layout/notification_scrubber.rb

@@ -0,0 +1,13 @@
+module AmaLayout
+  class NotificationScrubber < Rails::Html::PermitScrubber
+    def initialize
+      super
+      self.tags = %w(i a div span strong br em h1 h2 h3 h4 h5 h6 blockquote)
+      self.attributes = %w(href class id)
+    end
+
+    def skip_node?(node)
+      node.text?
+    end
+  end
+end

data/lib/ama_layout/notification_set.rb

@@ -0,0 +1,140 @@
+module AmaLayout
+  # An array-like object that handles the storage and retrieval of notifications
+  # from the underlying data store.
+  #
+  # The raw serialization format is JSON as follows (keys are SHA256 hashes):
+  #
+  # {
+  #   "57107043eab0f60a37f7735307dc6fc6709d04eec2dbeea8c284958057af9b77": {
+  #     "type": "notice",
+  #     "brand": "membership",
+  #     "header": "test",
+  #     "content": "test",
+  #     "created_at": "2017-06-19T11:26:57.730-06:00",
+  #     "lifespan": 31557600,
+  #     "active": true,
+  #     "version": "1.0.0"
+  #   }
+  # }
+  #
+  class NotificationSet
+    include Enumerable
+    attr_accessor :base, :data_store, :key
+
+    delegate :each, :first, :last, :size, :[], :empty?, :any?,  to: :all
+
+    def initialize(data_store, key)
+      self.data_store = data_store
+      self.key = key
+      self.base = fetch
+      clean!
+    end
+
+    def active
+      all.select(&:active?)
+    end
+
+    def all
+      @all ||= normalize(base_notifications)
+    end
+
+    def create(args = {})
+      args[:created_at] = Time.current
+      args[:active] = true
+      notification = Notification.new(args)
+      # previously dismissed notifications always take precendence
+      all.push(notification) unless base.key?(notification.digest)
+      save
+    end
+
+    def destroy!
+      data_store.delete(key) && reload!
+    end
+
+    def delete(*digests)
+      digests = Array.wrap(digests.flatten)
+      delta = all.reject { |n| digests.include?(n.digest) }
+      if delta != all
+        @all = delta
+        save
+      end
+    end
+
+    def find(digest)
+      all.find { |n| n.id == digest }
+    end
+
+    def save
+      data_store.transaction do |store|
+        normalized = normalize(all)
+        self.base = serialize(normalized)
+        store.set(key, base.to_json)
+      end
+      reload!
+    end
+
+    def inspect
+      "<#{self.class.name}>: #{all}"
+    end
+    alias_method :to_s, :inspect
+
+    private
+
+    def clean!
+      if dirty?
+        all.reject!(&:stale?)
+        save
+      end
+    end
+
+    def dirty?
+      all.any?(&:stale?)
+    end
+
+    def reload!
+      @all = nil
+      self.base = fetch
+      all
+      self
+    end
+
+    def base_notifications
+      base.map { |k, v| Notification.new(v.merge(id: k)) }
+    end
+
+    def serialize(data)
+      data.inject({}) do |hash, element|
+        hash[element.digest] = element.to_h
+        hash
+      end
+    end
+
+    def normalize(data)
+      # sort by reverse chronological order
+      data.sort { |a, b| b <=> a }
+    end
+
+    def fetch
+      result = data_store.get(key)
+      result.present? ? build(result) : {}
+    end
+
+    def build(raw)
+      JSON.parse(raw)
+    rescue JSON::ParserError
+      data_store.delete(key) # we should try to prevent further errors
+      ::Rails.logger.error json_message(__FILE__, __LINE__, raw)
+      {}
+    end
+
+    def json_message(file, line, raw)
+      {
+        error: "#{self.class.name} - Invalid JSON",
+        file: file,
+        line: line,
+        key: key,
+        raw: raw
+      }.to_json
+    end
+  end
+end

data/lib/ama_layout/notifications.rb

@@ -0,0 +1,73 @@
+module AmaLayout
+  # Usage:
+  #
+  # class MyClass
+  #   include AmaLayout::Notifications
+  #
+  #   notification_store AmaLayout::Notifications::RedisStore.new(options)
+  #   notification_foreign_key :a_method_name_or_proc # defaults to :id
+  #
+  #   ...
+  # end
+  #
+  module Notifications
+    InvalidNotificationStore = Class.new(StandardError)
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.include(InstanceMethods)
+    end
+
+    module InstanceMethods
+      def notifications
+        @notifications ||= NotificationSet.new(_store, _foreign_key)
+      end
+
+      def notifications=(other)
+        @notifications = other
+      end
+
+      private
+
+      def _store
+        self.class._notification_store || invalid_store!
+      end
+
+      def _foreign_key
+        self.class._notification_foreign_key.call(self)
+      end
+
+      def invalid_store!
+        raise InvalidNotificationStore, 'a notification store must be specified'
+      end
+    end
+
+    module ClassMethods
+      def notification_store(store)
+        self._notification_store = store
+      end
+
+      def notification_foreign_key(key)
+        self._notification_foreign_key = key
+      end
+
+      def _notification_foreign_key
+        @_notification_foreign_key || Proc.new(&:id)
+      end
+
+      def _notification_store
+        @_notification_store
+      end
+
+      private
+
+      def _notification_store=(store)
+        @_notification_store = store
+      end
+
+      def _notification_foreign_key=(key)
+        @_notification_foreign_key = key.to_proc
+      end
+    end
+  end
+end

data/lib/ama_layout/notifications/abstract_store.rb

@@ -0,0 +1,17 @@
+module AmaLayout
+  module Notifications
+    class AbstractStore
+      def get(key, opts = {})
+        raise NotImplementedError, 'you must define a #get method in a subclass'
+      end
+
+      def set(key, value, opts = {})
+        raise NotImplementedError, 'you must define a #set method in a subclass'
+      end
+
+      def delete(key, opts = {})
+        raise NotImplementedError, 'you must define a #delete method in a subclass'
+      end
+    end
+  end
+end

data/lib/ama_layout/notifications/redis_store.rb

@@ -0,0 +1,38 @@
+module AmaLayout
+  module Notifications
+    class RedisStore < AbstractStore
+      delegate :clear, to: :base
+
+      attr_accessor :base
+
+      def initialize(opts = {})
+        self.base = ActiveSupport::Cache.lookup_store(
+          :redis_store,
+          opts.merge(raw: true)
+        )
+      end
+
+      def get(key, opts = {})
+        if opts.fetch(:default, false)
+          base.fetch(key) { opts[:default] }
+        else
+          base.read(key)
+        end
+      end
+
+      def set(key, value, opts = {})
+        base.write(key, value, opts) == 'OK'
+      end
+
+      def delete(key, opts = {})
+        base.delete(key, opts) == 1
+      end
+
+      def transaction
+        base.data.multi do
+          yield self
+        end
+      end
+    end
+  end
+end

data/lib/ama_layout/version.rb

@@ -1,3 +1,3 @@
 module AmaLayout
-  VERSION = '6.3.0.pre'
+  VERSION = '6.10.0.pre'
 end

data/spec/ama_layout/controllers/ama_layout/api/v1/notifications_controller_spec.rb

@@ -0,0 +1,13 @@
+describe AmaLayout::Api::V1::NotificationsController, type: :controller do
+  describe 'DELETE api/v1/notifications' do
+    routes { AmaLayout::Engine.routes }
+
+    before(:each) do
+      delete :dismiss_all
+    end
+
+    it 'returns a 204 No Content status' do
+      expect(response).to have_http_status(:no_content)
+    end
+  end
+end

data/spec/ama_layout/decorators/navigation_decorator_spec.rb

@@ -7,8 +7,8 @@ describe AmaLayout::NavigationDecorator do
   let(:membership_site) { "http://membership.waffles.ca" }
   let(:driveredonline_site) { "http://driveredonline.waffles.ca" }
   let(:registries_site) { "http://registries.waffles.ca" }
-  let(:automotive_site) { "http://automotive.waffles.ca"}
-  let(:travel_site) { "http://travel.waffles.ca"}
+  let(:automotive_site) { "http://automotive.waffles.ca" }
+  let(:travel_site) { "http://travel.waffles.ca" }
 
   before(:each) do
     allow(Rails.configuration).to receive(:gatekeeper_site).and_return(gatekeeper_site)
@@ -129,4 +129,123 @@ describe AmaLayout::NavigationDecorator do
       expect(navigation_presenter.account_toggle).to eq "render"
     end
   end
+
+  context 'notification center' do
+    let(:store) do
+      AmaLayout::Notifications::RedisStore.new(
+        db: 4,
+        namespace: 'test_notifications',
+        host: 'localhost'
+      )
+    end
+    let(:notification_set) { AmaLayout::NotificationSet.new(store, 1) }
+    let(:user) { OpenStruct.new(navigation: 'member', notifications: notification_set) }
+    let(:navigation) { FactoryGirl.build :navigation, user: user }
+    subject { described_class.new(navigation) }
+
+    around(:each) do |example|
+      Timecop.freeze(Time.zone.local(2017, 6, 19)) do
+        store.clear
+        example.run
+        store.clear
+      end
+    end
+
+    describe '#notifications' do
+      it 'renders the content to the page' do
+        expect(subject.h).to receive(:render).once.and_return true
+        expect(subject.notifications).to be true
+      end
+    end
+
+    describe '#notification_badge' do
+      context 'with 1 active notification' do
+        before(:each) do
+          user.notifications.create(
+            type: :warning,
+            header: 'test',
+            content: 'test'
+          )
+        end
+
+        it 'returns a div with the count of active notifications' do
+          expect(subject.notification_badge).to include('div')
+          expect(subject.notification_badge).to include('1')
+        end
+      end
+
+      context 'with only inactive notifications' do
+        before(:each) do
+          user.notifications.create(
+            type: :warning,
+            header: 'test',
+            content: 'test'
+          )
+          user.notifications.first.dismiss!
+          user.notifications.save
+        end
+
+        it 'does not return the badge markup' do
+          expect(subject.notification_badge).to be nil
+        end
+      end
+
+      context 'with only active and inactive notifications' do
+        before(:each) do
+          user.notifications.create(
+            type: :warning,
+            header: 'test',
+            content: 'test'
+          )
+          2.times do |i|
+            user.notifications.create(
+              type: :notice,
+              header: i,
+              content: i
+            )
+          end
+          user.notifications.first.dismiss!
+          user.notifications.save
+        end
+
+        it 'returns a div with the count of active notifications' do
+          expect(subject.notification_badge).to include('div')
+          expect(subject.notification_badge).to include('2')
+        end
+      end
+    end
+
+    describe '#notification_sidebar' do
+      it 'renders content to the page' do
+        expect(subject.h).to receive(:render).once.and_return true
+        expect(subject.notification_sidebar).to be true
+      end
+    end
+
+    describe '#notifications_heading' do
+      context 'when notifications are present' do
+        before(:each) do
+          user.notifications.create(
+            type: :warning,
+            header: 'test',
+            content: 'test'
+          )
+        end
+
+        it 'returns the correct heading' do
+          expect(subject.notifications_heading).to include('Most Recent Notifications')
+        end
+      end
+
+      context 'when notifications are not present' do
+        it 'returns the correct heading' do
+          expect(subject.notifications_heading).to include('No Recent Notifications')
+        end
+
+        it 'italicizes the message' do
+          expect(subject.notifications_heading).to include('italic')
+        end
+      end
+    end
+  end
 end