goca-spree-backend 3.1.14.rails.5.0

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

@@ -0,0 +1,40 @@
+module Spree
+  module Admin
+    class GeneralSettingsController < Spree::Admin::BaseController
+      include Spree::Backend::Callbacks
+
+      before_action :set_store
+
+      def edit
+        @preferences_security = []
+      end
+
+      def update
+        params.each do |name, value|
+          next unless Spree::Config.has_preference? name
+          Spree::Config[name] = value
+        end
+
+        current_store.update_attributes store_params
+
+        flash[:success] = Spree.t(:successfully_updated, resource: Spree.t(:general_settings))
+        redirect_to edit_admin_general_settings_path
+      end
+
+      def clear_cache
+        Rails.cache.clear
+        invoke_callbacks(:clear_cache, :after)
+        head :no_content
+      end
+
+      private
+      def store_params
+        params.require(:store).permit(permitted_store_attributes)
+      end
+
+      def set_store
+        @store = current_store
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Spree
+  module Admin
+    class ImagesController < ResourceController
+      before_action :load_edit_data, except: :index
+      before_action :load_index_data, only: :index
+
+      create.before :set_viewable
+      update.before :set_viewable
+
+      private
+
+      def location_after_destroy
+        admin_product_images_url(@product)
+      end
+
+      def location_after_save
+        admin_product_images_url(@product)
+      end
+
+      def load_index_data
+        @product = Product.friendly.includes(*variant_index_includes).find(params[:product_id])
+      end
+
+      def load_edit_data
+        @product = Product.friendly.includes(*variant_edit_includes).find(params[:product_id])
+        @variants = @product.variants.map do |variant|
+          [variant.sku_and_options_text, variant.id]
+        end
+        @variants.insert(0, [Spree.t(:all), @product.master.id])
+      end
+
+      def set_viewable
+        @image.viewable_type = 'Spree::Variant'
+        @image.viewable_id = params[:image][:viewable_id]
+      end
+
+      def variant_index_includes
+        [
+          variant_images: [viewable: { option_values: :option_type }]
+        ]
+      end
+
+      def variant_edit_includes
+        [
+          variants_including_master: { option_values: :option_type, images: :viewable }
+        ]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Spree
+  module Admin
+    class LogEntriesController < Spree::Admin::BaseController
+      before_action :find_order_and_payment
+
+      def index
+        @log_entries = @payment.log_entries
+      end
+
+
+      private
+
+      def find_order_and_payment
+        @order = Spree::Order.friendly.find(params[:order_id])
+        @payment = @order.payments.friendly.find(params[:payment_id])
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+module Spree
+  module Admin
+    class OptionTypesController < ResourceController
+      before_action :setup_new_option_value, only: :edit
+
+      def update_values_positions
+        ActiveRecord::Base.transaction do
+          params[:positions].each do |id, index|
+            Spree::OptionValue.where(id: id).update_all(position: index)
+          end
+        end
+
+        respond_to do |format|
+          format.html { redirect_to admin_product_variants_url(params[:product_id]) }
+          format.js { render text: 'Ok' }
+        end
+      end
+
+      protected
+
+        def location_after_save
+          if @option_type.created_at == @option_type.updated_at
+            edit_admin_option_type_url(@option_type)
+          else
+            admin_option_types_url
+          end
+        end
+
+
+      private
+        def load_product
+          @product = Product.friendly.find(params[:product_id])
+        end
+
+        def setup_new_option_value
+          @option_type.option_values.build if @option_type.option_values.empty?
+        end
+
+        def set_available_option_types
+          @available_option_types = if @product.option_type_ids.any?
+            OptionType.where.not(id: @product.option_type_ids)
+          else
+            OptionType.all
+          end
+        end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Spree
+  module Admin
+    class OptionValuesController < Spree::Admin::BaseController
+      def destroy
+        option_value = Spree::OptionValue.find(params[:id])
+        option_value.destroy
+        render text: nil
+      end
+    end
+  end
+end

data/app/controllers/spree/admin/orders/customer_details_controller.rb

@@ -0,0 +1,74 @@
+module Spree
+  module Admin
+    module Orders
+      class CustomerDetailsController < Spree::Admin::BaseController
+        before_action :load_order
+        before_action :load_user, only: :update, unless: :guest_checkout?
+
+        def show
+          edit
+          render action: :edit
+        end
+
+        def edit
+          country_id = Address.default.country.id
+          @order.build_bill_address(country_id: country_id) if @order.bill_address.nil?
+          @order.build_ship_address(country_id: country_id) if @order.ship_address.nil?
+
+          @order.bill_address.country_id = country_id if @order.bill_address.country.nil?
+          @order.ship_address.country_id = country_id if @order.ship_address.country.nil?
+        end
+
+        def update
+          if @order.update_attributes(order_params)
+            @order.associate_user!(@user, @order.email.blank?) unless guest_checkout?
+            @order.next unless @order.complete?
+            @order.refresh_shipment_rates(Spree::ShippingMethod::DISPLAY_ON_FRONT_AND_BACK_END)
+
+            if @order.errors.empty?
+              flash[:success] = Spree.t('customer_details_updated')
+              redirect_to edit_admin_order_url(@order)
+            else
+              render action: :edit
+            end
+          else
+            render action: :edit
+          end
+        end
+
+        private
+
+        def order_params
+          params.require(:order).permit(
+            :email,
+            :use_billing,
+            bill_address_attributes: permitted_address_attributes,
+            ship_address_attributes: permitted_address_attributes
+          )
+        end
+
+        def load_order
+          @order = Order.includes(:adjustments).friendly.find(params[:order_id])
+        end
+
+        def model_class
+          Spree::Order
+        end
+
+        def load_user
+          @user = (Spree.user_class.find_by(id: params[:user_id]) ||
+            Spree.user_class.find_by(email: order_params[:email]))
+
+          unless @user
+            flash.now[:error] = Spree.t(:user_not_found)
+            render :edit
+          end
+        end
+
+        def guest_checkout?
+          params[:guest_checkout] == 'true'
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,147 @@
+module Spree
+  module Admin
+    class OrdersController < Spree::Admin::BaseController
+      before_action :initialize_order_events
+      before_action :load_order, only: [:edit, :update, :cancel, :resume, :approve, :resend, :open_adjustments, :close_adjustments, :cart]
+
+      respond_to :html
+
+      def index
+        params[:q] ||= {}
+        params[:q][:completed_at_not_null] ||= '1' if Spree::Config[:show_only_complete_orders_by_default]
+        @show_only_completed = params[:q][:completed_at_not_null] == '1'
+        params[:q][:s] ||= @show_only_completed ? 'completed_at desc' : 'created_at desc'
+        params[:q][:completed_at_not_null] = '' unless @show_only_completed
+
+        # As date params are deleted if @show_only_completed, store
+        # the original date so we can restore them into the params
+        # after the search
+        created_at_gt = params[:q][:created_at_gt]
+        created_at_lt = params[:q][:created_at_lt]
+
+        params[:q].delete(:inventory_units_shipment_id_null) if params[:q][:inventory_units_shipment_id_null] == "0"
+
+        if params[:q][:created_at_gt].present?
+          params[:q][:created_at_gt] = Time.zone.parse(params[:q][:created_at_gt]).beginning_of_day rescue ""
+        end
+
+        if params[:q][:created_at_lt].present?
+          params[:q][:created_at_lt] = Time.zone.parse(params[:q][:created_at_lt]).end_of_day rescue ""
+        end
+
+        if @show_only_completed
+          params[:q][:completed_at_gt] = params[:q].delete(:created_at_gt)
+          params[:q][:completed_at_lt] = params[:q].delete(:created_at_lt)
+        end
+
+        @search = Order.preload(:user).accessible_by(current_ability, :index).ransack(params[:q])
+
+        # lazy loading other models here (via includes) may result in an invalid query
+        # e.g. SELECT  DISTINCT DISTINCT "spree_orders".id, "spree_orders"."created_at" AS alias_0 FROM "spree_orders"
+        # see https://github.com/spree/spree/pull/3919
+        @orders = @search.result(distinct: true).
+          page(params[:page]).
+          per(params[:per_page] || Spree::Config[:orders_per_page])
+
+        # Restore dates
+        params[:q][:created_at_gt] = created_at_gt
+        params[:q][:created_at_lt] = created_at_lt
+      end
+
+      def new
+        @order = Order.create(order_params)
+        redirect_to cart_admin_order_url(@order)
+      end
+
+      def edit
+        can_not_transition_without_customer_info
+
+        @order.refresh_shipment_rates(ShippingMethod::DISPLAY_ON_FRONT_AND_BACK_END)
+      end
+
+      def cart
+        unless @order.completed?
+          @order.refresh_shipment_rates
+        end
+        if @order.shipments.shipped.count > 0
+          redirect_to edit_admin_order_url(@order)
+        end
+      end
+
+      def update
+        if @order.update_attributes(params[:order]) && @order.line_items.present?
+          @order.update_with_updater!
+          unless @order.completed?
+            # Jump to next step if order is not completed.
+            redirect_to admin_order_customer_path(@order) and return
+          end
+        else
+          @order.errors.add(:line_items, Spree.t('errors.messages.blank')) if @order.line_items.empty?
+        end
+
+        render action: :edit
+      end
+
+      def cancel
+        @order.canceled_by(try_spree_current_user)
+        flash[:success] = Spree.t(:order_canceled)
+        redirect_to :back
+      end
+
+      def resume
+        @order.resume!
+        flash[:success] = Spree.t(:order_resumed)
+        redirect_to :back
+      end
+
+      def approve
+        @order.approved_by(try_spree_current_user)
+        flash[:success] = Spree.t(:order_approved)
+        redirect_to :back
+      end
+
+      def resend
+        OrderMailer.confirm_email(@order.id, true).deliver_later
+        flash[:success] = Spree.t(:order_email_resent)
+
+        redirect_to :back
+      end
+
+      def open_adjustments
+        adjustments = @order.all_adjustments.closed
+        adjustments.update_all(state: 'open')
+        flash[:success] = Spree.t(:all_adjustments_opened)
+
+        respond_with(@order) { |format| format.html { redirect_to :back } }
+      end
+
+      def close_adjustments
+        adjustments = @order.all_adjustments.open
+        adjustments.update_all(state: 'closed')
+        flash[:success] = Spree.t(:all_adjustments_closed)
+
+        respond_with(@order) { |format| format.html { redirect_to :back } }
+      end
+
+      private
+        def order_params
+          params[:created_by_id] = try_spree_current_user.try(:id)
+          params.permit(:created_by_id, :user_id)
+        end
+
+        def load_order
+          @order = Order.includes(:adjustments).friendly.find(params[:id])
+          authorize! action, @order
+        end
+
+        # Used for extensions which need to provide their own custom event links on the order details view.
+        def initialize_order_events
+          @order_events = %w{approve cancel resume}
+        end
+
+        def model_class
+          Spree::Order
+        end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Spree
+  module Admin
+    class PaymentMethodsController < ResourceController
+      skip_before_action :load_resource, only: :create
+      before_action :load_data
+      before_action :validate_payment_method_provider, only: :create
+
+      respond_to :html
+
+      def create
+        @payment_method = params[:payment_method].delete(:type).constantize.new(payment_method_params)
+        @object = @payment_method
+        invoke_callbacks(:create, :before)
+        if @payment_method.save
+          invoke_callbacks(:create, :after)
+          flash[:success] = Spree.t(:successfully_created, resource: Spree.t(:payment_method))
+          redirect_to edit_admin_payment_method_path(@payment_method)
+        else
+          invoke_callbacks(:create, :fails)
+          respond_with(@payment_method)
+        end
+      end
+
+      def update
+        invoke_callbacks(:update, :before)
+        payment_method_type = params[:payment_method].delete(:type)
+        if @payment_method['type'].to_s != payment_method_type
+          @payment_method.update_columns(
+            type: payment_method_type,
+            updated_at: Time.current,
+          )
+          @payment_method = PaymentMethod.find(params[:id])
+        end
+
+        update_params = params[ActiveModel::Naming.param_key(@payment_method)] || {}
+        attributes = payment_method_params.merge(update_params)
+        attributes.each do |k,v|
+          if k.include?("password") && attributes[k].blank?
+            attributes.delete(k)
+          end
+        end
+
+        if @payment_method.update_attributes(attributes)
+          invoke_callbacks(:update, :after)
+          flash[:success] = Spree.t(:successfully_updated, resource: Spree.t(:payment_method))
+          redirect_to edit_admin_payment_method_path(@payment_method)
+        else
+          invoke_callbacks(:update, :fails)
+          respond_with(@payment_method)
+        end
+      end
+
+      private
+
+      def load_data
+        @providers = Gateway.providers.sort{|p1, p2| p1.name <=> p2.name }
+      end
+
+      def validate_payment_method_provider
+        valid_payment_methods = Rails.application.config.spree.payment_methods.map(&:to_s)
+        if !valid_payment_methods.include?(params[:payment_method][:type])
+          flash[:error] = Spree.t(:invalid_payment_provider)
+          redirect_to new_admin_payment_method_path
+        end
+      end
+
+      def payment_method_params
+        params.require(:payment_method).permit!
+      end
+    end
+  end
+end

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

@@ -0,0 +1,103 @@
+module Spree
+  module Admin
+    class PaymentsController < Spree::Admin::BaseController
+      include Spree::Backend::Callbacks
+
+      before_action :load_order, only: [:create, :new, :index, :fire]
+      before_action :load_payment, except: [:create, :new, :index]
+      before_action :load_data
+      before_action :can_not_transition_without_customer_info
+
+      respond_to :html
+
+      def index
+        @payments = @order.payments.includes(refunds: :reason)
+        @refunds = @payments.flat_map(&:refunds)
+        redirect_to new_admin_order_payment_url(@order) if @payments.empty?
+      end
+
+      def new
+        @payment = @order.payments.build
+      end
+
+      def create
+        invoke_callbacks(:create, :before)
+        @payment ||= @order.payments.build(object_params)
+        if @payment.payment_method.source_required? && params[:card].present? and params[:card] != 'new'
+          @payment.source = @payment.payment_method.payment_source_class.find_by_id(params[:card])
+        end
+
+        begin
+          if @payment.save
+            invoke_callbacks(:create, :after)
+            # Transition order as far as it will go.
+            while @order.next; end
+            # If "@order.next" didn't trigger payment processing already (e.g. if the order was
+            # already complete) then trigger it manually now
+            @payment.process! if @order.completed? && @payment.checkout?
+            flash[:success] = flash_message_for(@payment, :successfully_created)
+            redirect_to admin_order_payments_path(@order)
+          else
+            invoke_callbacks(:create, :fails)
+            flash[:error] = Spree.t(:payment_could_not_be_created)
+            render :new
+          end
+        rescue Spree::Core::GatewayError => e
+          invoke_callbacks(:create, :fails)
+          flash[:error] = "#{e.message}"
+          redirect_to new_admin_order_payment_path(@order)
+        end
+      end
+
+      def fire
+        return unless event = params[:e] and @payment.payment_source
+
+        # Because we have a transition method also called void, we do this to avoid conflicts.
+        event = "void_transaction" if event == "void"
+        if @payment.send("#{event}!")
+          flash[:success] = Spree.t(:payment_updated)
+        else
+          flash[:error] = Spree.t(:cannot_perform_operation)
+        end
+      rescue Spree::Core::GatewayError => ge
+        flash[:error] = "#{ge.message}"
+      ensure
+        redirect_to admin_order_payments_path(@order)
+      end
+
+      private
+
+      def object_params
+        if params[:payment] and params[:payment_source] and source_params = params.delete(:payment_source)[params[:payment][:payment_method_id]]
+          params[:payment][:source_attributes] = source_params
+        end
+
+        params.require(:payment).permit(permitted_payment_attributes)
+      end
+
+      def load_data
+        @amount = params[:amount] || load_order.total
+        @payment_methods = PaymentMethod.available_on_back_end
+        if @payment and @payment.payment_method
+          @payment_method = @payment.payment_method
+        else
+          @payment_method = @payment_methods.first
+        end
+      end
+
+      def load_order
+        @order = Order.friendly.find(params[:order_id])
+        authorize! action, @order
+        @order
+      end
+
+      def load_payment
+        @payment = Payment.friendly.find(params[:id])
+      end
+
+      def model_class
+        Spree::Payment
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Spree
+  module Admin
+    class ProductPropertiesController < ResourceController
+      belongs_to 'spree/product', :find_by => :slug
+      before_action :find_properties
+      before_action :setup_property, only: :index
+
+      private
+        def find_properties
+          @properties = Spree::Property.pluck(:name)
+        end
+
+        def setup_property
+          @product.product_properties.build
+        end
+    end
+  end
+end