[#137627] add links to 10 most recently purchased products to home page (#1429)

giladshanan · web-flow · commit dc3e3a800415 · 2018-03-16T14:14:52.000-05:00
Add a list of the user's 10 most recently purchased products to the user's home page.
diff --git a/app/controllers/application_controller.rb b/app/controllers/application_controller.rb
@@ -88,7 +88,7 @@ def manageable_facilities
       when current_facility.blank?
         session_user.manageable_facilities
       when current_facility.cross_facility?
-        Facility.sorted
+        Facility.alphabetized
       else
         Facility.where(id: current_facility.id)
       end
diff --git a/app/controllers/facilities_controller.rb b/app/controllers/facilities_controller.rb
@@ -8,7 +8,6 @@ class FacilitiesController < ApplicationController
   before_action :check_acting_as, except: [:index, :show]
   before_action :load_order_details, only: [:confirm_transactions, :move_transactions, :reassign_chart_strings]
   before_action :set_admin_billing_tab, only: [:confirm_transactions, :disputed_orders, :movable_transactions, :transactions]
-  before_action :set_recently_used_facilities, only: [:index]
   before_action :store_fullpath_in_session, only: [:index, :show]
 
   load_and_authorize_resource find_by: :url_name
@@ -23,11 +22,6 @@ class FacilitiesController < ApplicationController
     action_name.in?(%w(disputed_orders movable_transactions transactions)) ? "two_column_head" : "two_column"
   }
 
-  def set_recently_used_facilities
-    @recently_used_facilities =
-      acting_user.present? && acting_user.recently_used_facilities.sorted
-  end
-
   cattr_accessor(:facility_homepage_redirector) { DefaultFacilityHomepageRedirector }
 
   # GET /facilities/:facility_url/dashboard
@@ -37,8 +31,10 @@ def dashboard
 
   # GET /facilities
   def index
-    @facilities = Facility.active.sorted
+    @facilities = Facility.active.alphabetized
+    @recently_used_facilities = MostRecentlyUsedSearcher.new(acting_user).recently_used_facilities.alphabetized
     @active_tab = "home"
+    @recent_products = MostRecentlyUsedSearcher.new(acting_user).recently_used_products.includes(:facility).alphabetized
     render layout: "application"
   end
 
@@ -57,7 +53,7 @@ def list
     # show list of operable facilities for current user, and admins manage all facilities
     @active_tab = "manage_facilites"
     if session_user.administrator?
-      @facilities = Facility.sorted
+      @facilities = Facility.alphabetized
       flash.now[:notice] = "No facilities have been added" if @facilities.empty?
     else
       @facilities = operable_facilities
diff --git a/app/helpers/products_helper.rb b/app/helpers/products_helper.rb
@@ -28,7 +28,7 @@ def options_for_relay
   def public_calendar_link(product)
     if product.respond_to? :reservations
       opts = public_calendar_options(product)
-      link_to "", facility_instrument_public_schedule_path(current_facility, product), opts
+      link_to "", facility_instrument_public_schedule_path(product.facility, product), opts
     end
   end
 
@@ -43,7 +43,7 @@ def product_url_hint(product)
   private
 
   def public_calendar_options(product)
-    if current_facility.show_instrument_availability?
+    if current_facility&.show_instrument_availability? || !current_facility && product.facility.show_instrument_availability?
       public_calendar_availability_options(product)
     else
       { class: ["fa fa-calendar fa-2x"],
diff --git a/app/models/concerns/users/roles.rb b/app/models/concerns/users/roles.rb
@@ -25,18 +25,18 @@ module Roles
     # Returns relation of facilities for which this user is staff, a director, or an admin
     def operable_facilities
       if administrator?
-        Facility.sorted
+        Facility.alphabetized
       else
-        facilities.sorted.where(user_roles: { role: UserRole.facility_roles })
+        facilities.alphabetized.where(user_roles: { role: UserRole.facility_roles })
       end
     end
 
     # Returns relation of facilities for which this user is a director or admin
     def manageable_facilities
       if administrator? || billing_administrator?
-        Facility.sorted
+        Facility.alphabetized
       else
-        facilities.sorted.where(user_roles: { role: UserRole.facility_management_roles })
+        facilities.alphabetized.where(user_roles: { role: UserRole.facility_management_roles })
       end
     end
 
diff --git a/app/models/facility.rb b/app/models/facility.rb
@@ -43,7 +43,7 @@ def accounts
   delegate :in_dispute, to: :order_details, prefix: true
 
   scope :active, -> { where(is_active: true) }
-  scope :sorted, -> { order(:name) }
+  scope :alphabetized, -> { order(:name) }
 
   cattr_accessor :facility_account_validators { [] }
 
diff --git a/app/models/product.rb b/app/models/product.rb
@@ -59,7 +59,7 @@ class Product < ActiveRecord::Base
 
   scope :active, -> { where(is_archived: false, is_hidden: false) }
   scope :active_plus_hidden, -> { where(is_archived: false) } # TODO: phase out in favor of the .not_archived scope
-  scope :alphabetized, -> { order("lower(name)") }
+  scope :alphabetized, -> { order("lower(products.name)") }
   scope :archived, -> { where(is_archived: true) }
   scope :not_archived, -> { where(is_archived: false) }
   scope :mergeable_into_order, -> { not_archived.where(type: mergeable_types) }
diff --git a/app/models/user.rb b/app/models/user.rb
@@ -175,14 +175,6 @@ def deactivated_string
     end
   end
 
-  def recently_used_facilities(limit = 5)
-    @recently_used_facilities ||= Hash.new do |hash, key|
-      facility_ids = orders.purchased.order("MAX(ordered_at) DESC").limit(limit).group(:facility_id).pluck(:facility_id)
-      hash[key] = Facility.where(id: facility_ids).sorted
-    end
-    @recently_used_facilities[limit]
-  end
-
   # Devise uses this method for determining if a user is allowed to log in. It
   # also gets called on each request, so if a user gets deactivated, they'll be
   # kicked out of their session.
diff --git a/app/services/most_recently_used_searcher.rb b/app/services/most_recently_used_searcher.rb
@@ -0,0 +1,23 @@
+class MostRecentlyUsedSearcher
+
+  attr_reader :user
+
+  def initialize(user)
+    @user = user
+  end
+
+  def recently_used_facilities(limit = 5)
+    return [] unless user
+
+    facility_ids = user.orders.purchased.order("MAX(ordered_at) DESC").limit(limit).group(:facility_id).pluck(:facility_id)
+    Facility.where(id: facility_ids)
+  end
+
+  def recently_used_products(limit = 10)
+    return [] unless user
+
+    product_ids = user.orders.joins(order_details: :product).merge(Product.active.in_active_facility).purchased.order("MAX(orders.ordered_at) DESC").limit(limit).group(:product_id).pluck(:product_id)
+    Product.where(id: product_ids)
+  end
+
+end
diff --git a/app/views/facilities/_product_list.html.haml b/app/views/facilities/_product_list.html.haml
@@ -1,8 +1,11 @@
 - if products.any?
   .product_list{ class: products.first.class.model_name.to_s.pluralize.downcase }
-    %h3= product_list_title products, local_assigns[:title_extra]
-    - if products.first.class.model_name == "TimedService"
-      %p= t("facilities.show.timed_services_note")
+
+    - if current_facility.present?
+      %h3= product_list_title products, local_assigns[:title_extra]
+
+      - if products.first.class.model_name == "TimedService"
+        %p= t("facilities.show.timed_services_note")
     %ul
       - products.sort.each do |product|
         %li{ class: product.class.model_name.to_s.downcase }
@@ -12,7 +15,7 @@
               - if session_user.can_override_restrictions?(product) || product.can_be_used_by?(acting_user)
                 = builder.text_field :quantity, value: 0, class: "product_quantity", index: nil
                 = builder.hidden_field :product_id, value: product.id, index: nil
-          = link_to product.name + (product.is_hidden? ? ' (hidden)' : ''), facility_product_path(current_facility, product)
+          = link_to product.name + (product.is_hidden? ? ' (hidden)' : ''), facility_product_path(current_facility || product.facility, product)
           - if acting_user.present? && !product.can_be_used_by?(acting_user)
             %i.fa.fa-lock
             = " (#{product.class.human_attribute_name(:requires_approval_show)})"
diff --git a/app/views/facilities/index.html.haml b/app/views/facilities/index.html.haml
@@ -13,11 +13,18 @@
     - @recently_used_facilities.each do |facility|
       %h4.header-tight= link_to facility, facility_path(facility)
     %hr
-    %h4= text(".all")
 
+  - if @recent_products.any?
+
+    %h4= text(".recently_purchased")
+    = render 'product_list', products: @recent_products
+    %hr
+
+  %h4= text(".all")
   - @facilities.each do |facility|
     %h4.header-tight= link_to facility, facility_path(facility)
     %p= facility.short_description
 
 - else
   .alert.alert-info= t(".empty", items: Facility.model_name.human(count: 2))
+
diff --git a/config/locales/views/en.facilities.yml b/config/locales/views/en.facilities.yml
@@ -3,6 +3,7 @@ en:
     facilities:
       index:
         recently_used: Recently Used !Facilities!
+        recently_purchased: Recently Purchased Products
         all: All !Facilities!
         welcome: |
           Welcome to !app_name!, the centralized ordering system for shared !facilities_downcase!.
diff --git a/spec/models/user_spec.rb b/spec/models/user_spec.rb
@@ -190,66 +190,6 @@
     end
   end
 
-  describe "#recently_used_facilities" do
-    subject { user.recently_used_facilities(limit) }
-    let(:account) { create(:setup_account, owner: user) }
-    let(:facilities) { products.map(&:facility) }
-    let(:limit) { 5 }
-    let(:products) { create_list(:setup_item, 6) }
-    let(:user) { create(:user) }
-
-    context "when the user has no orders" do
-      it { expect(subject).to be_empty }
-    end
-
-    context "a user has made an update very recently" do
-      let!(:old_order) { create(:setup_order, :purchased, account: account, product: products.first, user: user, ordered_at: 1.week.ago) }
-      let!(:new_order) { create(:setup_order, :purchased, account: account, product: products.second, user: user, ordered_at: 1.day.ago) }
-      let!(:unpurchased_order) { create(:setup_order, account: account, product: products.third, user: user) }
-
-      context "bubbling up the newest" do
-        let(:limit) { 1 }
-        it { is_expected.to eq([facilities.second]) }
-      end
-
-      context "ordering by name" do
-        let(:limit) { 2 }
-        it { is_expected.to eq(facilities.first(2)) }
-      end
-
-      context "excludes unpurchased" do
-        let(:limit) { 3 }
-        it { is_expected.to eq(facilities.first(2)) }
-      end
-    end
-
-    context "when the user has orders" do
-      before(:each) do
-        products.first(order_count).each_with_index do |product, i|
-          create(:setup_order, :purchased, account: account, product: product, user: user, ordered_at: i.days.ago)
-        end
-      end
-
-      context "made in fewer than 5 facilities" do
-        let(:order_count) { 4 }
-
-        it { expect(subject).to eq(facilities.first(order_count)) }
-      end
-
-      context "made in 5 facilities" do
-        let(:order_count) { 5 }
-
-        it { expect(subject).to eq(facilities.first(order_count)) }
-      end
-
-      context "made in more than 5 facilities" do
-        let(:order_count) { 6 }
-
-        it { expect(subject).to eq(facilities.first(limit)) }
-      end
-    end
-  end
-
   describe "#deactivate" do
     it "deactivates the user" do
       expect { user.deactivate }.to change(user, :active?).to(false)
diff --git a/spec/services/most_recently_used_searcher_spec.rb b/spec/services/most_recently_used_searcher_spec.rb
@@ -0,0 +1,76 @@
+require "rails_helper"
+
+RSpec.describe MostRecentlyUsedSearcher do
+  describe "#recently_used_facilities" do
+    let(:account) { create(:setup_account, owner: user) }
+    let(:facilities) { products.map(&:facility) }
+    let(:limit) { 5 }
+    let(:products) { create_list(:setup_item, 6) }
+    let(:user) { create(:user) }
+    let(:recently_used_facilities) { MostRecentlyUsedSearcher.new(user).recently_used_facilities(limit) }
+
+    context "when the user has no orders" do
+      it { expect(recently_used_facilities).to be_empty }
+    end
+
+    context "when the user has orders" do
+      let!(:old_order) { create(:setup_order, :purchased, account: account, product: products.first, user: user, ordered_at: 1.week.ago) }
+      let!(:new_order) { create(:setup_order, :purchased, account: account, product: products.second, user: user, ordered_at: 1.day.ago) }
+      let!(:unpurchased_order) { create(:setup_order, account: account, product: products.third, user: user) }
+
+      it "returns facilities that the user has ordered from" do
+        expect(recently_used_facilities).to contain_exactly(new_order.facility, old_order.facility)
+      end
+
+      context "when there are orders in more facilities than the limit" do
+        before(:each) do
+          products.each_with_index do |product, i|
+            create(:setup_order, :purchased, account: account, product: product, user: user, ordered_at: i.days.ago)
+          end
+        end
+
+        it "returns only 5 facilities" do
+          expect(recently_used_facilities.length).to eq 5
+        end
+      end
+
+    end
+  end
+
+  describe "#recently_used_products" do
+    let(:account) { create(:setup_account, owner: user) }
+    let(:facilities) { products.map(&:facility) }
+    let(:limit) { 5 }
+    let(:products) { create_list(:setup_item, 6) }
+    let(:user) { create(:user) }
+    let(:recently_used_products) { MostRecentlyUsedSearcher.new(user).recently_used_products(limit) }
+
+    context "when the user has no orders" do
+      it { expect(recently_used_products).to be_empty }
+    end
+
+    context "when the user has orders" do
+      let!(:old_order) { create(:setup_order, :purchased, account: account, product: products.first, user: user, ordered_at: 1.week.ago) }
+      let!(:new_order) { create(:setup_order, :purchased, account: account, product: products.second, user: user, ordered_at: 1.day.ago) }
+      let!(:unpurchased_order) { create(:setup_order, account: account, product: products.third, user: user) }
+
+      it "returns products that the user has ordered" do
+        expect(recently_used_products).to contain_exactly(new_order.order_details.first.product, old_order.order_details.first.product)
+      end
+
+      context "when there are more recently used products than the limit" do
+        before(:each) do
+          products.each_with_index do |product, i|
+            create(:setup_order, :purchased, account: account, product: product, user: user, ordered_at: i.days.ago)
+          end
+        end
+
+        it "returns only 5 products" do
+          expect(recently_used_products.length).to eq 5
+        end
+      end
+
+    end
+  end
+
+end
