workarea-reviews 3.0.8

data/app/controllers/workarea/admin/catalog_products_controller.decorator

@@ -0,0 +1,9 @@
+module Workarea
+  decorate Admin::CatalogProductsController, with: :reviews do
+    decorated { helper Admin::ReviewsHelper }
+
+    def reviews
+      @reviews = Review.find_for_product(@product.id, true)
+    end
+  end
+end

data/app/controllers/workarea/admin/import_reviews_controller.rb

@@ -0,0 +1,35 @@
+module Workarea
+  module Admin
+    class ImportReviewsController < Admin::ApplicationController
+      required_permissions :marketing
+
+      def new
+        @import = Import::Review.new
+      end
+
+      def create
+        @import = Import::Review.new(import_params)
+
+        if @import.save
+          ProcessImport.perform_async(@import.to_global_id)
+
+          flash[:success] = t('workarea.admin.import_reviews.flash_messages.processing')
+          redirect_to reviews_path
+        else
+          render :new, status: :unprocessable_entity
+        end
+      end
+
+      def sample
+        send_file Reviews::Engine.root.join('public/workarea/import_samples/reviews.csv')
+      end
+
+      private
+
+      def import_params
+        params.fetch(:import_review, {})
+              .merge(created_by_id: current_user.id)
+      end
+    end
+  end
+end

data/app/controllers/workarea/admin/reviews_controller.rb

@@ -0,0 +1,51 @@
+module Workarea
+  class Admin::ReviewsController < Admin::ApplicationController
+    required_permissions :marketing
+    before_action :find_review, except: :index
+
+    def index
+      search = Search::AdminReviews.new(params.merge(autocomplete: request.xhr?))
+      @search = Admin::ReviewsSearchViewModel.new(search, view_model_options)
+    end
+
+    def show
+      redirect_to edit_review_path(@review)
+    end
+
+    def edit; end
+
+    def update
+      if @review.update_attributes(review_params)
+        flash[:success] = t('workarea.admin.reviews.flash_messages.updated')
+        redirect_to reviews_path
+      else
+        render :edit
+      end
+    end
+
+    def destroy
+      @review.destroy
+      flash[:success] = t('workarea.admin.reviews.flash_messages.destroyed')
+      if params[:product].present?
+        redirect_to reviews_catalog_product_path(params[:product])
+      else
+        redirect_to reviews_path
+      end
+    end
+
+    private
+
+    def find_review
+      if params[:id].present?
+        review = Review.find(params[:id])
+        @review = Admin::ReviewViewModel.wrap(review)
+        @user = User.find(review.user_id) rescue nil
+      end
+    end
+
+    def review_params
+      return {} if params[:review].blank?
+      params[:review].permit(:body, :approved, :rating, :title)
+    end
+  end
+end

data/app/controllers/workarea/storefront/review_requests_controller.rb

@@ -0,0 +1,50 @@
+module Workarea
+  module Storefront
+    class ReviewRequestsController < Storefront::ApplicationController
+      before_action :validate_request
+      before_action :find_product, :set_review
+
+      def show; end
+
+      def complete
+        if verify_recaptcha(model: @review, env: Rails.env) && @review.save
+          @request.complete!
+          Review::Request.cancel_for_orders!(@request.order_id)
+
+          flash[:success] = t('workarea.storefront.reviews.flash_messages.created')
+          redirect_to product_path(@product)
+        else
+          flash[:error] = t('workarea.storefront.reviews.flash_messages.failure')
+          render :show
+        end
+      end
+
+      private
+
+      def validate_request
+        @request = Review::Request.find_by_token(params[:id])
+
+        if @request.nil? || @request.completed?
+          flash[:error] = t('workarea.storefront.review_requests.flash_messages.already_submitted')
+          redirect_to(root_path) && (return)
+        end
+      end
+
+      def find_product
+        model = Catalog::Product.find(@request.product_id)
+        @product = ProductViewModel.wrap(model, view_model_options)
+      end
+
+      def set_review
+        @review = ReviewViewModel.wrap(Review.new(review_params))
+      end
+
+      def review_params
+        ReviewRequestParams.new(
+          @request,
+          params[:review]&.permit(:rating, :title, :body)&.to_h || {}
+        ).to_h
+      end
+    end
+  end
+end

data/app/controllers/workarea/storefront/reviews_controller.rb

@@ -0,0 +1,53 @@
+module Workarea
+  module Storefront
+    class ReviewsController < Storefront::ApplicationController
+      before_action :find_product
+      before_action :set_review
+
+      def new; end
+
+      def create
+        if review_can_be_saved? && @create_review.save
+          redirect_to product_path(params[:product_id])
+          flash[:success] = t('workarea.storefront.reviews.flash_messages.created')
+        else
+          render :new
+          flash[:error] = t('workarea.storefront.reviews.flash_messages.failure')
+        end
+      end
+
+      private
+
+      def set_review
+        @create_review = CreateReview.for(
+          product: @product,
+          user: current_user,
+          params: review_params.to_h
+        )
+
+        @review = ReviewViewModel.wrap(@create_review.review)
+      end
+
+      def find_product
+        @product ||=
+          begin
+            model = Catalog::Product.find_by(slug: params[:product_id])
+            raise InvalidDisplay unless model.active? || current_user.try(:admin?)
+            ProductViewModel.wrap(model)
+          end
+      end
+
+      def review_params
+        return {} unless params[:review].present?
+
+        params[:review].permit(
+          :product_id, :rating, :title, :body, :first_name, :last_name, :email
+        )
+      end
+
+      def review_can_be_saved?
+        verify_recaptcha(model: @create_review, env: Rails.env)
+      end
+    end
+  end
+end

data/app/helpers/workarea/admin/reviews_helper.rb

@@ -0,0 +1,12 @@
+module Workarea
+  module Admin
+    module ReviewsHelper
+      def reviewer_info(model)
+        return model.user_info unless model.user_id.present?
+
+        link_to model.user_info,
+                edit_user_path(model.user_id)
+      end
+    end
+  end
+end

data/app/helpers/workarea/storefront/reviews_helper.rb

@@ -0,0 +1,24 @@
+module Workarea
+  module Storefront
+    module ReviewsHelper
+      def rating_stars(rating, options = {})
+        full_star_count = rating.floor
+        empty_star_count = 5 - rating.ceil
+        half_star_size = (rating % 1).round(2) * 100
+        half_star_width = 20 + (half_star_size - 0) * (80.0 - 20) / (100.0 - 0)
+        itemprop = options[:aggregate] ? 'aggregateRating' : 'reviewRating'
+        itemtype = options[:aggregate] ? 'http://schema.org/AggregateRating' : 'http://schema.org/Rating'
+
+        render 'workarea/storefront/products/rating', rating: rating, full_star_count: full_star_count, empty_star_count: empty_star_count, half_star_width: half_star_width, half_star_size: half_star_size, itemprop: itemprop, itemtype: itemtype
+      end
+
+      def display_purchase_requirement_message
+        if current_user && Workarea.config.require_purchase_to_post_review && current_user.total_spent.to_f.zero?
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end

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/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/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/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