spree_admin 5.0.0.rc1

data/app/controllers/spree/admin/addresses_controller.rb

@@ -0,0 +1,86 @@
+module Spree
+  module Admin
+    class AddressesController < ResourceController
+      before_action :set_new_address_country, only: :new
+
+      def create
+        user = Spree.user_class.find(params[:user_id])
+
+        result = create_service.call(
+          address_params: permitted_resource_params,
+          user: user,
+          default_shipping: params[:default_shipping].to_b,
+          default_billing: params[:default_billing].to_b
+        )
+
+        @address = @object = result.value
+
+        if result.success?
+          set_current_store
+
+          flash[:success] = flash_message_for(@address, :successfully_created)
+          redirect_to location_after_save, status: :see_other
+        else
+          render action: :edit, status: :unprocessable_entity
+        end
+      end
+
+      def update
+        order = address_user_current_order
+
+        result = update_service.call(
+          address: @address,
+          address_params: permitted_resource_params,
+          order: order,
+          address_changes_except: address_update_address_changes_except
+        )
+
+        @address = @object = result.value
+
+        if result.success?
+          set_current_store
+
+          flash[:success] = flash_message_for(@address, :successfully_updated)
+          redirect_to location_after_save, status: :see_other
+        else
+          render action: :edit, status: :unprocessable_entity
+        end
+      end
+
+      private
+
+      def set_new_address_country
+        @address.country = current_store.default_country
+      end
+
+      def create_service
+        Spree::Dependencies.address_create_service.constantize
+      end
+
+      def update_service
+        Spree::Dependencies.address_update_service.constantize
+      end
+
+      def address_update_address_changes_except
+        []
+      end
+
+      def address_user_current_order
+        incomplete_orders = @address.user.orders.incomplete
+        incomplete_orders.where(ship_address: @address).or(incomplete_orders.where(bill_address: @address)).first
+      end
+
+      def location_after_save
+        spree.admin_user_url(@address.user)
+      end
+
+      def collection_url
+        if @address.user.present?
+          spree.admin_user_url(@address.user)
+        else
+          spree.admin_users_url
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/assets_controller.rb

@@ -0,0 +1,70 @@
+module Spree
+  module Admin
+    class AssetsController < ResourceController
+      include Spree::Admin::SessionAssetsHelper
+
+      ALLOWED_ASSET_TYPES = ['Spree::Asset', 'Spree::Image'].freeze
+
+      def create
+        if ALLOWED_ASSET_TYPES.include?(asset_type)
+          @asset = asset_type.constantize.new(permitted_resource_params)
+        else
+          raise "Invalid asset type"
+        end
+
+        # we only should check this for vendor users
+        authorize! :update, @asset.viewable if @asset.viewable.present? && current_vendor
+
+        if @asset.save
+          @product = @asset.product || current_store.products.new
+
+          # we need to store the asset ids in the session to be able to display them in the product page
+          store_uploaded_asset_in_session(@asset) if @product.new_record?
+        else
+          flash.now[:error] = @asset.errors.full_messages.to_sentence
+          render :create, status: :unprocessable_entity
+        end
+      end
+
+      def update
+        authorize! :update, @asset.viewable if @asset.viewable.present? && current_vendor
+
+        if @asset.update(permitted_resource_params)
+          respond_to do |format|
+            format.turbo_stream
+            format.json { render json: @asset }
+          end
+        else
+          head :unprocessable_entity
+        end
+      end
+
+      def bulk_destroy
+        @assets = model_class.accessible_by(current_ability).where(id: params[:ids])
+        @assets.destroy_all
+      end
+
+      private
+
+      def permitted_resource_params
+        params.require(:asset).permit(:type, :viewable_id, :viewable_type, :attachment, :alt, :position)
+      end
+
+      def create_turbo_stream_enabled?
+        true
+      end
+
+      def update_turbo_stream_enabled?
+        true
+      end
+
+      def destroy_turbo_stream_enabled?
+        true
+      end
+
+      def asset_type
+        permitted_resource_params[:type] || model_class.to_s
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/base_controller.rb

@@ -0,0 +1,131 @@
+module Spree
+  module Admin
+    class BaseController < Spree::BaseController
+      layout :choose_layout
+
+      helper 'spree/base'
+      helper 'spree/admin/navigation'
+      helper 'spree/locale'
+      helper 'spree/currency'
+      helper 'spree/addresses'
+
+      before_action :authorize_admin
+
+      protected
+
+      def action
+        params[:action].to_sym
+      end
+
+      def authorize_admin
+        record = if respond_to?(:model_class, true) && model_class
+                   model_class
+                 else
+                   controller_name.to_sym
+                 end
+        authorize! :admin, record
+        authorize! action, record
+      end
+
+      def redirect_unauthorized_access
+        if try_spree_current_user
+          flash[:error] = Spree.t(:authorization_failure)
+          redirect_to spree.admin_forbidden_path, allow_other_host: true
+        else
+          store_location
+          if defined?(spree_admin_login_path)
+            redirect_to spree_admin_login_path, allow_other_host: true
+          elsif respond_to?(:spree_login_path)
+            redirect_to spree_login_path, allow_other_host: true
+          elsif spree.respond_to?(:root_path)
+            redirect_to spree.root_path, allow_other_host: true
+          else
+            redirect_to main_app.respond_to?(:root_path) ? main_app.root_path : '/'
+          end
+        end
+      end
+
+      def try_spree_current_user
+        if Spree.admin_user_class
+          send("current_#{Spree.admin_user_class.model_name.singular_route_key}")
+        else
+          # use Spree::Core::ControllerHelpers::Auth#try_spree_current_user
+          super
+        end
+      end
+
+      def flash_message_for(object, event_sym)
+        if object.is_a?(ActiveRecord::Relation)
+          resource_desc = object.model.model_name.human.pluralize
+        else
+          resource_desc = object.class.model_name.human
+          if (object.persisted? || object.destroyed?) && object.respond_to?(:name) && object.name.present? && !object.is_a?(Spree::Order)
+            resource_desc += " \"#{object.name}\""
+          end
+        end
+
+        Spree.t(event_sym, resource: resource_desc)
+      end
+
+      def config_locale
+        I18n.default_locale
+      end
+
+      def current_timezone
+        @current_timezone ||= current_store.preferred_timezone
+      end
+
+      def current_currency
+        @current_currency ||= if params[:currency].present? && supported_currency?(params[:currency])
+                                params[:currency]
+                              elsif current_store.present?
+                                current_store.default_currency
+                              else
+                                Spree::Store.default.default_currency
+                              end&.upcase
+      end
+
+      def current_vendor
+        nil
+      end
+
+      def set_return_to
+        return unless defined?(model_class)
+        return unless request.format.html?
+
+        clear_return_to
+
+        session_key = "#{model_class.to_s.demodulize.pluralize.downcase}_return_to".to_sym
+        session[session_key] = "#{request.path}?#{request.query_string}"
+      rescue ActionDispatch::Cookies::CookieOverflow
+        clear_return_to
+      end
+
+      def clear_return_to
+        session.keys.find_all { |k| k.ends_with?('_return_to') }.each do |k|
+          session.delete(k)
+        end
+      end
+
+      def remove_assets(attachment_types, object: nil)
+        attachment_types.each do |attachment_type|
+          remove_param = "remove_#{attachment_type}"
+          if params[remove_param] == '1'
+            object ||= attachment_type == 'asset' ? @page_section : @object
+            attachment = object.public_send(attachment_type)
+            if attachment.attached?
+              attachment.detach
+              attachment.purge_later
+            end
+          end
+        end
+      end
+
+      def choose_layout
+        return 'turbo_rails/frame' if turbo_frame_request?
+
+        'spree/admin'
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/checkouts_controller.rb

@@ -0,0 +1,23 @@
+module Spree
+  module Admin
+    class CheckoutsController < BaseController
+      include Spree::Admin::OrdersFiltersHelper
+
+      before_action :load_user, only: [:index]
+
+      def index
+        params[:q] ||= {}
+        params[:q][:s] ||= 'created_at desc'
+
+        load_orders
+        render template: 'spree/admin/orders/index'
+      end
+
+      private
+
+      def scope
+        current_store.checkouts.accessible_by(current_ability, :index)
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/classifications_controller.rb

@@ -0,0 +1,74 @@
+module Spree
+  module Admin
+    class ClassificationsController < ResourceController
+      belongs_to 'spree/taxon', find_by: :id
+
+      layout 'turbo_rails/frame'
+
+      before_action :load_sorted_classifications, only: %i[create index]
+
+      # create classifications in bulk
+      def create
+        products = current_store.products.accessible_by(current_ability, :update).where(id: params[:product_ids].compact.uniq)
+        Spree::Taxons::AddProducts.call(taxons: Spree::Taxon.where(id: parent.id), products: products)
+
+        parent.reload
+        @classifications = collection
+      end
+
+      private
+
+      def collection_url
+        spree.admin_taxon_classifications_path(@parent.id)
+      end
+
+      def update_turbo_stream_enabled?
+        true
+      end
+
+      def destroy_turbo_stream_enabled?
+        true
+      end
+
+      def collection
+        @collection ||= parent.
+                        classifications.
+                        joins(:product).
+                        merge(current_store.products.not_archived).
+                        includes(
+                          :taxon,
+                          product: {
+                            variant_images: [],
+                            master: [:images, :stock_items, :stock_locations],
+                            variants: [:images, :stock_items, :stock_locations]
+                          }
+                        ).
+                        accessible_by(current_ability)
+      end
+
+      def load_sorted_classifications
+        return @sorted_classifications if @sorted_classifications.present?
+
+        sort_params = { sort: taxon_sort_order_to_param(parent.sort_order) }
+        @sorted_classifications = Spree::Classifications::Sort.new(collection, current_currency, sort_params).call
+      end
+
+      def taxon_sort_order_to_param(sort_order)
+        return unless sort_order
+
+        sort_orders = {
+          'manual' => 'manual',
+          'best-selling' => '-best_selling',
+          'name-a-z' => 'name',
+          'name-z-a' => '-name',
+          'price-low-to-high' => 'price',
+          'price-high-to-low' => '-price',
+          'newest-first' => '-available_on',
+          'oldest-first' => 'available_on'
+        }
+
+        sort_orders.fetch(sort_order.to_s, 'manual')
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/coupon_codes_controller.rb

@@ -0,0 +1,21 @@
+module Spree
+  module Admin
+    class CouponCodesController < ResourceController
+      belongs_to 'spree/promotion', find_by: :id
+
+      def collection
+        return @collection if @collection.present?
+
+        @collection = super
+
+        params[:q] ||= {}
+        @search = @collection.ransack(params[:q])
+        @collection = if request.format.csv?
+                        @search.result
+                      else
+                        @search.result.page(params[:page])
+                      end
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/custom_domains_controller.rb

@@ -0,0 +1,19 @@
+module Spree
+  module Admin
+    class CustomDomainsController < ResourceController
+      protected
+
+      def collection_url
+        spree.admin_custom_domains_path
+      end
+
+      def create_turbo_stream_enabled?
+        helpers.entri_enabled?
+      end
+
+      def location_after_save
+        spree.admin_custom_domains_path
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/customer_returns_controller.rb

@@ -0,0 +1,20 @@
+module Spree
+  module Admin
+    class CustomerReturnsController < ResourceController
+      def index; end
+
+      private
+
+      def collection
+        return @collection if @collection.present?
+
+        params[:q] ||= {}
+
+        # @search needs to be defined as this is passed to search_form_for
+        @search = current_store.customer_returns.accessible_by(current_ability, :index).ransack(params[:q])
+        per_page = params[:per_page]
+        @collection = @search.result.order(created_at: :desc).page(params[:page]).per(per_page)
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/dashboard_controller.rb

@@ -0,0 +1,145 @@
+module Spree
+  module Admin
+    class DashboardController < BaseController
+      include Spree::Admin::AnalyticsConcern
+
+      before_action :set_analytics_defaults, only: %i[analytics]
+      before_action :load_vendor
+      before_action :clear_return_to, only: %i[show]
+
+      def show; end
+
+      def getting_started; end
+
+      def analytics
+        @orders_scope = current_store.orders.complete.where(currency: params[:analytics_currency])
+        @products_scope = current_store.products
+
+        if defined?(Spree::Vendor)
+          # for vendors we need to count there sub-orders
+          # for admins we need to counnt only the main orders (the ones that are splitted)
+          @orders_scope = if @vendor.present?
+                            @orders_scope.with_vendor(@vendor.id)
+                          elsif @orders_scope.respond_to?(:without_vendor)
+                            @orders_scope.without_vendor
+                          end
+        end
+
+        load_top_products
+
+        sales_total_sum = @orders_scope.where(completed_at: analytics_time_range).sum(:total)
+        @sales_total = Spree::Money.new(sales_total_sum, currency: params[:analytics_currency])
+        previous_sales_total = @orders_scope.where(completed_at: previous_analytics_time_range).sum(:total)
+        @sales_growth_rate = calc_growth_rate(sales_total_sum, previous_sales_total)
+
+        @orders_total = @orders_scope.where(completed_at: analytics_time_range).count
+        previous_orders_total = @orders_scope.where(completed_at: previous_analytics_time_range).count
+        @orders_growth_rate = calc_growth_rate(@orders_total, previous_orders_total)
+
+        orders_avg = @orders_scope.where(completed_at: analytics_time_range).average(:total).to_f
+        @orders_average = Spree::Money.new(orders_avg, currency: params[:analytics_currency])
+        previous_orders_average = @orders_scope.where(completed_at: previous_analytics_time_range).average(:total).to_f
+        @orders_average_growth_rate = calc_growth_rate(orders_avg, previous_orders_average)
+
+        @grouped_orders_scope = if same_day?
+                                  @orders_scope.group_by_hour(:completed_at, range: analytics_time_range, time_zone: current_store.preferred_timezone,
+                                                                             default_value: 0.0)
+                                else
+                                  @orders_scope.group_by_day(:completed_at, range: analytics_time_range, time_zone: current_store.preferred_timezone,
+                                                                            default_value: 0.0)
+                                end
+
+        load_analytics_data
+      end
+
+      # PATCH /admin/dashboard/dismiss_enterprise_edition_notice
+      def dismiss_enterprise_edition_notice
+        session[:spree_enterprise_edition_notice_dismissed] = true
+        redirect_back(fallback_location: spree.admin_dashboard_path)
+      end
+
+      private
+
+      def load_vendor
+        return unless defined?(Spree::Vendor)
+
+        @vendor = current_vendor || (Spree::Vendor.find(params[:vendor_id]) if params[:vendor_id].present?)
+      end
+
+      def load_top_products
+        line_items_grouped = Spree::LineItem.
+                             select('
+                              sum(quantity) AS all_quantity,
+                              sum(quantity * price) AS all_amount,
+                              spree_variants.product_id AS variant_product_id
+                            ').
+                             joins(:variant).
+                             where(order: current_store.orders.complete.where('spree_orders.currency': params[:analytics_currency]).where('spree_orders.completed_at': analytics_time_range)).
+                             order('all_amount desc, all_quantity desc').
+                             group('variant_product_id')
+
+        line_items_grouped = line_items_grouped.joins(:product).where('spree_products.vendor_id': @vendor.id) if @vendor.present?
+        line_items_grouped = line_items_grouped.limit(5)
+
+        product_ids = line_items_grouped.map(&:variant_product_id).uniq.compact
+
+        return if product_ids.empty?
+
+        products = current_store.products.with_deleted.includes(:master, :variants).where(id: product_ids)
+
+        @top_products = line_items_grouped.map do |li|
+          product = products.find { |p| p.id == li.variant_product_id }
+          next unless product.present?
+
+          {
+            product: product,
+            quantity: li.all_quantity,
+            amount: Spree::Money.new(li.all_amount, currency: params[:analytics_currency])
+          }
+        end.compact
+      end
+
+      def load_analytics_data
+        return if @vendor.present?
+
+        @audience_scope = Spree.user_class.where(created_at: analytics_time_range)
+        @audience_total = @audience_scope.count
+        previous_audience_total = Spree.user_class.where(created_at: previous_analytics_time_range).count
+        @audience_growth_rate = calc_growth_rate(@audience_total, previous_audience_total)
+
+        @audience = if same_day?
+                      @audience_scope.group_by_hour(:created_at, range: analytics_time_range, time_zone: current_store.preferred_timezone, default_value: 0)
+                    else
+                      @audience_scope.group_by_day(:created_at, range: analytics_time_range, time_zone: current_store.preferred_timezone, default_value: 0)
+                    end
+
+        return unless defined?(Ahoy)
+
+        @visits_scope = Ahoy::Visit.where(started_at: analytics_time_range)
+        @visits_total = @visits_scope.count
+        previous_visits_total = Ahoy::Visit.where(started_at: previous_analytics_time_range).count
+        @visits_growth_rate = calc_growth_rate(@visits_total, previous_visits_total)
+
+        @visits_scope = Ahoy::Visit.where(started_at: analytics_time_range)
+        @visits_total = @visits_scope.count
+        previous_visits_total = Ahoy::Visit.where(started_at: previous_analytics_time_range).count
+        @visits_growth_rate = calc_growth_rate(@visits_total, previous_visits_total)
+
+        @visits = if same_day?
+                    @visits_scope.group_by_hour(:started_at, range: analytics_time_range, time_zone: current_store.preferred_timezone, default_value: 0)
+                  else
+                    @visits_scope.group_by_day(:started_at, range: analytics_time_range, time_zone: current_store.preferred_timezone, default_value: 0)
+                  end
+
+        @top_landing_pages = @visits_scope.where.not(landing_page_title: [nil, '']).top(:landing_page_title, 10)
+        @top_referrers = @visits_scope.where.not(referring_domain: current_store.custom_domains.pluck(:url) << current_store.url).top(
+          :referring_domain, 10
+        )
+        @top_locations = @visits_scope.top(:country, 10)
+        @top_devices = @visits_scope.group(:device_type).count.transform_keys do |device|
+                        device.nil? ? 'N/A' : device
+                      end.map { |series| [series.first, (series.second.to_f / @visits_scope.count) * 100] }
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/digital_assets_controller.rb

@@ -0,0 +1,45 @@
+module Spree
+  module Admin
+    class DigitalAssetsController < ResourceController
+      belongs_to 'spree/product', find_by: :slug
+
+      private
+
+      def model_class
+        Spree::Digital
+      end
+
+      def collection
+        parent.digitals
+      end
+
+      def collection_url
+        spree.admin_product_digital_assets_path(parent)
+      end
+
+      def build_resource
+        parent.digitals.build
+      end
+
+      def find_resource
+        parent.digitals.find(params[:id])
+      end
+
+      def create_turbo_stream_enabled?
+        @object.errors.any?
+      end
+
+      def update_turbo_stream_enabled?
+        @object.errors.any?
+      end
+
+      def location_after_save
+        spree.admin_product_digital_assets_path(parent)
+      end
+
+      def permitted_resource_params
+        params.require(:digital_asset).permit(permitted_digital_attributes)
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/errors_controller.rb

@@ -0,0 +1,11 @@
+module Spree
+  module Admin
+    class ErrorsController < BaseController
+      skip_before_action :authorize_admin
+
+      def forbidden
+        render status: 403
+      end
+    end
+  end
+end