workarea-reviews 3.0.10

data/app/mailers/workarea/admin/status_report_mailer.decorator

@@ -0,0 +1,8 @@
+module Workarea
+  decorate Admin::StatusReportMailer, with: :reviews do
+    def report(email, date)
+      @reviews_summary =  ReviewSummary.new
+      super
+    end
+  end
+end

data/app/mailers/workarea/storefront/review_mailer.rb

@@ -0,0 +1,23 @@
+module Workarea
+  module Storefront
+    class ReviewMailer < Storefront::ApplicationMailer
+      include TransactionalMailer
+
+      def review_request(request_id)
+        @request = Review::Request.find(request_id)
+        @content = Content::Email.find_content('review_request')
+        @product = Storefront::ProductViewModel.wrap(
+          Catalog::Product.find(@request.product_id)
+        )
+
+        mail(
+          to: @request.email,
+          subject: t(
+            'workarea.storefront.email.review_request.subject',
+            product: @product.name
+          )
+        )
+      end
+    end
+  end
+end

data/app/models/workarea/catalog/product.decorator

@@ -0,0 +1,15 @@
+module Workarea
+  decorate Catalog::Product, with: :reviews do
+    decorated do
+      # @!attribute total_reviews
+      #   @return [Integer] the total number of approved reviews
+      #
+      field :total_reviews, type: Integer, default: 0
+
+      # @!attribute average_rating
+      #   @return [Float] the average rating of approved reviews
+      #
+      field :average_rating,  type: Float
+    end
+  end
+end

data/app/models/workarea/fulfillment.decorator

@@ -0,0 +1,11 @@
+module Workarea
+  decorate Fulfillment, with: :reviews do
+    def ship_items(tracking_number, shipped_items)
+      super.tap do |result|
+        if result && Workarea.config.send_transactional_emails
+          ScheduleReviewRequests.perform_async(id, shipped_items)
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/review.rb

@@ -0,0 +1,135 @@
+module Workarea
+  class Review
+    include ApplicationDocument
+
+    field :user_id, type: String
+    field :user_info, type: String
+    field :first_name, type: String
+    field :last_name, type: String
+    field :email, type: String
+    field :product_id, type: String
+    field :rating, type: Integer
+    field :title, type: String
+    field :body, type: String
+    field :approved, type: Boolean, default: false
+    field :verified, type: Boolean, default: false
+
+    index(product_id: 1, approved: 1)
+    index(approved: 1)
+    index(created_at: 1)
+
+    validates :product_id, presence: true
+    validates :user_info, presence: true
+    validates :body, presence: true
+    validates :rating, presence: true,
+      numericality: {
+        greater_than_or_equal_to: 1,
+        less_than_or_equal_to: 5,
+        only_integer: true
+      }
+
+    validate :user_must_have_spent_money_to_create_review
+
+    before_save :ensure_title
+
+    scope :by_product, ->(id) { where(product_id: id) }
+    scope :approved, -> { where(approved: true) }
+    scope :pending,  -> { where(approved: false) }
+
+    def self.sorts
+      [ Workarea::Sort.pending,
+        Workarea::Sort.newest,
+        Workarea::Sort.modified,
+        Workarea::Sort.title,
+        Workarea::Sort.rating ]
+    end
+
+    # Get {Mongoid::Criteria} for the reviews for a certain product.
+    # Optionally allow including unapproved reviews (for the admin).
+    #
+    # @param [String] product_id
+    # @param [optional, Boolean] allow_unapproved
+    # @return [Mongoid::Criteria]
+    #
+    def self.find_for_product(product_id, allow_unapproved = false)
+      criteria = by_product(product_id)
+      allow_unapproved ? criteria : criteria.approved
+    end
+
+    # Lookup aggregate stats on product reviews for a product.
+    #
+    # @param [String] product_id
+    # @return [Hash]
+    #
+    def self.find_single_aggregates(product_id)
+      stats = by_product(product_id).approved.aggregates(:rating)
+      { count: stats['count'] || 0, average: stats['avg'] || 0 }
+    end
+
+    # Lookup aggregate review stats on multiple products.
+    # Used for show stats on browse/detail.
+    #
+    # @param [Array<String>] product_ids
+    # @return [Hash] results Keys are product IDs, values are stats Hash
+    #
+    def self.find_aggregates(*product_ids)
+      product_ids = Array(product_ids).flatten
+
+      if product_ids.one?
+        find_single_aggregates(product_ids.first)
+      else
+        product_ids.inject({}) do |memo, product_id|
+          memo[product_id] = find_single_aggregates(product_id)
+          memo
+        end
+      end
+    end
+
+    # Find sort score for a product. Used in the search index for sorting by
+    # best reviewed.
+    #
+    # Balances a small number of ratings with the uncertainty of only having a few ratings.
+    # See: http://masanjin.net/blog/how-to-rank-products-based-on-user-input
+    #
+    # @param [String] product_id
+    # @return [Float]
+    #
+    def self.find_sorting_score(product_id)
+      reviews = find_for_product(product_id)
+
+      votes = [ reviews.select { |r| r.rating == 1 }.length,
+                reviews.select { |r| r.rating == 2 }.length,
+                reviews.select { |r| r.rating == 3 }.length,
+                reviews.select { |r| r.rating == 4 }.length,
+                reviews.select { |r| r.rating == 5 }.length ]
+
+      prior = [2, 2, 2, 2, 2]
+
+      posterior = votes.zip(prior).map { |a, b| a + b }
+      sum = posterior.inject { |a, b| a + b }
+
+      posterior.
+        map.with_index { |v, i| (i + 1) * v }.
+        inject { |a, b| a + b }.
+        to_f / sum
+    end
+
+    def anonymous?
+      !user_id.present?
+    end
+
+    def ensure_title
+      self.title = body.truncate(50) if title.blank?
+    end
+
+    def user_must_have_spent_money_to_create_review
+      if Workarea.config.require_purchase_to_post_review
+        user = User.find(user_id)
+        if user.total_spent.to_f.zero?
+          err_msg = I18n.t('workarea.storefront.reviews.total_spent_validation')
+          errors.add(:user, err_msg)
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/review/request.rb

@@ -0,0 +1,62 @@
+module Workarea
+  class Review
+    class Request
+      include ApplicationDocument
+      include UrlToken
+
+      field :order_id, type: String
+      field :user_id, type: String
+      field :product_id, type: String
+
+      field :email, type: String
+
+      field :send_after, type: DateTime
+      field :sent_at, type: DateTime
+      field :completed_at, type: DateTime
+      field :canceled_at, type: DateTime
+
+      index(order_id: 1)
+      index(send_after: 1, sent_at: 1, canceled_at: 1)
+
+      index(
+        { created_at: 1 },
+        { expire_after_seconds: Workarea.config.review_request_ttl }
+      )
+
+      scope :by_order, ->(order_id) { where(order_id: order_id) }
+      scope :ready_to_send, ->(from = Time.current) do
+        where(:send_after.lte => from, :sent_at => nil, :canceled_at => nil)
+      end
+
+      def self.cancel_for_orders!(order_ids)
+        self.in(order_id: Array.wrap(order_ids))
+            .where(completed_at: nil)
+            .update_all(canceled_at: Time.current)
+      end
+
+      def scheduled?
+        send_after.present?
+      end
+
+      def sent?
+        sent_at.present?
+      end
+
+      def completed?
+        completed_at.present? || canceled?
+      end
+
+      def canceled?
+        canceled_at.present?
+      end
+
+      def complete!
+        update_attributes(completed_at: Time.current)
+      end
+
+      def send!
+        update_attributes(sent_at: Time.current)
+      end
+    end
+  end
+end

data/app/models/workarea/search/admin/review.rb

@@ -0,0 +1,72 @@
+module Workarea
+  module Search
+    class Admin
+      class Review < Search::Admin
+        def type
+          'review'
+        end
+
+        def status
+          'active'
+        end
+
+        def facets
+          super.merge(
+            state: state,
+            rating: model.rating,
+            verification: verification
+          )
+        end
+
+        def jump_to_text
+          nil
+        end
+
+        def name
+          nil
+        end
+
+        def jump_to_position
+          6
+        end
+
+        def search_text
+          [model.product_id, model.user_id]
+        end
+
+        def review_text
+          [model.title, model.body, product&.name].compact
+        end
+
+        def state
+          if model.approved?
+            I18n.t('workarea.admin.reviews.approved')
+          else
+            I18n.t('workarea.admin.reviews.pending')
+          end
+        end
+
+        def verification
+          if model.verified?
+            I18n.t('workarea.admin.reviews.verified')
+          else
+            I18n.t('workarea.admin.reviews.unverified')
+          end
+        end
+
+        def as_document
+          super.merge(
+            review_text: review_text,
+            rating: model.rating
+          )
+        end
+
+        private
+
+        def product
+          @product ||= Catalog::Product.find(model.product_id) rescue nil
+        end
+      end
+    end
+  end
+end

data/app/models/workarea/search/storefront/product.decorator

@@ -0,0 +1,9 @@
+module Workarea
+  decorate Search::Storefront::Product, with: :reviews do
+    def sorts
+      super.merge(
+        rating: Review.find_sorting_score(model.id)
+      )
+    end
+  end
+end

data/app/models/workarea/sort.decorator

@@ -0,0 +1,17 @@
+module Workarea
+  decorate Sort, with: :reviews do
+    class_methods do
+      def top_rated
+        new(I18n.t('workarea.sorts.top_rated'), :top_rated, :'sorts.rating', :desc)
+      end
+
+      def highest_rating
+        new(I18n.t('workarea.sorts.highest_rating'), :highest_rating, :rating, :desc)
+      end
+
+      def lowest_rating
+        new(I18n.t('workarea.sorts.lowest_rating'), :lowest_rating, :rating, :asc)
+      end
+    end
+  end
+end

data/app/queries/workarea/review_request_params.rb

@@ -0,0 +1,47 @@
+module Workarea
+  class ReviewRequestParams
+    attr_reader :request, :params
+
+    def initialize(request, params)
+      @request = request
+      @params = params
+    end
+
+    def to_h
+      params.merge(
+        product_id: @request.product_id,
+        user_id: @request.user_id,
+        email: @request.email,
+        user_info: user_info,
+        first_name: first_name,
+        last_name: last_name,
+        verified: true
+      )
+    end
+
+    private
+
+    def user_info
+      return user.public_info if user&.public_info.present?
+
+      [first_name.first, last_name.first].join
+    end
+
+    def first_name
+      user&.first_name || billing_address.first_name
+    end
+
+    def last_name
+      user&.last_name || billing_address.last_name
+    end
+
+    def user
+      return nil unless @request.user_id.present?
+      @user ||= User.find(@request.user_id)
+    end
+
+    def billing_address
+      @billing_address ||= Payment.find(@request.order_id).address
+    end
+  end
+end

data/app/queries/workarea/review_summary.rb

@@ -0,0 +1,11 @@
+module Workarea
+  class ReviewSummary
+    def pending_reviews_count
+      @pending_reviews_count ||= Review.pending.count
+    end
+
+    def recent_reviews_count
+      @recent_reviews_count ||= Review.where(:created_at.gte => 1.day.ago).count
+    end
+  end
+end

data/app/queries/workarea/search/admin_reviews.rb

@@ -0,0 +1,40 @@
+module Workarea
+  module Search
+    class AdminReviews
+      include Query
+      include AdminIndexSearch
+      include AdminSorting
+      include Pagination
+
+      document Search::Admin
+
+      def initialize(params = {})
+        super(params.merge(type: 'review'))
+      end
+
+      def fields
+        super + %w(review_text)
+      end
+
+      def facets
+        super + [
+          TermsFacet.new(self, 'state'),
+          TermsFacet.new(self, 'rating'),
+          TermsFacet.new(self, 'verification')
+        ]
+      end
+
+      def sort
+        result = super || []
+
+        if params[:sort] == Sort.highest_rating.to_s
+          result.prepend(Sort.highest_rating.field => Sort.highest_rating.direction)
+        elsif params[:sort] == Sort.lowest_rating.to_s
+          result.prepend(Sort.lowest_rating.field => Sort.lowest_rating.direction)
+        end
+
+        result
+      end
+    end
+  end
+end