spree_backend 2.0.0.rc1

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,40 @@
+module Spree
+  module Admin
+    module Orders
+      class CustomerDetailsController < Spree::Admin::BaseController
+        before_filter :load_order
+
+        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?
+        end
+
+        def update
+          if @order.update_attributes(params[:order])
+            while @order.next; end
+
+            @order.shipments.map &:refresh_rates
+            flash[:success] = Spree.t('customer_details_updated')
+            redirect_to admin_order_customer_path(@order)
+          else
+            render :action => :edit
+          end
+
+        end
+
+        private
+
+          def load_order
+            @order = Order.find_by_number!(params[:order_id], :include => :adjustments)
+          end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,133 @@
+module Spree
+  module Admin
+    class OrdersController < Spree::Admin::BaseController
+      require 'spree/core/gateway_error'
+      before_filter :initialize_order_events
+      before_filter :load_order, :only => [:edit, :update, :fire, :resend, :open_adjustments, :close_adjustments]
+
+      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].present?
+        params[:q][:s] ||= @show_only_completed ? 'completed_at desc' : 'created_at desc'
+
+        # 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].blank?
+          params[:q][:created_at_gt] = Time.zone.parse(params[:q][:created_at_gt]).beginning_of_day rescue ""
+        end
+
+        if !params[:q][:created_at_lt].blank?
+          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.accessible_by(current_ability, :index).ransack(params[:q])
+        @orders = @search.result.includes([:user, :shipments, :payments]).
+          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
+        redirect_to edit_admin_order_url(@order)
+      end
+
+      def edit
+        @order.shipments.map &:refresh_rates
+      end
+
+      def update
+        return_path = nil
+        if @order.update_attributes(params[:order]) && @order.line_items.present?
+          @order.update!
+          unless @order.complete?
+            # Jump to next step if order is not complete.
+            return_path = admin_order_customer_path(@order)
+          else
+            # Otherwise, go back to first page since all necessary information has been filled out.
+            return_path = admin_order_path(@order)
+          end
+        else
+          @order.errors.add(:line_items, Spree.t('errors.messages.blank')) if @order.line_items.empty?
+        end
+
+        if return_path
+          redirect_to return_path
+        else
+          render :action => :edit
+        end
+      end
+
+      def fire
+        # TODO - possible security check here but right now any admin can before any transition (and the state machine
+        # itself will make sure transitions are not applied in the wrong state)
+        event = params[:e]
+        if @order.send("#{event}")
+          flash[:success] = Spree.t(:order_updated)
+        else
+          flash[:error] = Spree.t(:cannot_perform_operation)
+        end
+      rescue Spree::Core::GatewayError => ge
+        flash[:error] = "#{ge.message}"
+      ensure
+        redirect_to :back
+      end
+
+      def resend
+        OrderMailer.confirm_email(@order.id, true).deliver
+        flash[:success] = Spree.t(:order_email_resent)
+
+        redirect_to :back
+      end
+
+      def open_adjustments
+        adjustments = @order.adjustments.where(:state => '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.adjustments.where(:state => '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 load_order
+          @order = Order.find_by_number!(params[:id], :include => :adjustments) if 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{cancel resume}
+        end
+
+        def model_class
+          Spree::Order
+        end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# this clas was inspired (heavily) from the mephisto admin architecture
+module Spree
+  module Admin
+    class OverviewController < Spree::Admin::BaseController
+      #todo, add rss feed of information that is happening
+
+      def index
+        @users = User.all
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+module Spree
+  module Admin
+    class PaymentMethodsController < ResourceController
+      skip_before_filter :load_resource, :only => [:create]
+      before_filter :load_data
+      before_filter :validate_payment_method_provider, :only => :create
+
+      respond_to :html
+
+      def create
+        @payment_method = params[:payment_method].delete(:type).constantize.new(params[:payment_method])
+        @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_column(:type, payment_method_type)
+          @payment_method = PaymentMethod.find(params[:id])
+        end
+
+        payment_method_params = params[ActiveModel::Naming.param_key(@payment_method)] || {}
+        attributes = params[:payment_method].merge(payment_method_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
+    end
+  end
+end

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

@@ -0,0 +1,111 @@
+module Spree
+  module Admin
+    class PaymentsController < Spree::Admin::BaseController
+      before_filter :load_order, :only => [:create, :new, :index, :fire]
+      before_filter :load_payment, :except => [:create, :new, :index]
+      before_filter :load_data
+      before_filter :can_transition_to_payment
+
+      respond_to :html
+
+      def index
+        @payments = @order.payments
+        redirect_to new_admin_order_payment_url(@order) if @payments.empty?
+      end
+
+      def new
+        @payment = @order.payments.build
+      end
+
+      def create
+        @payment = @order.payments.build(object_params)
+        if @payment.payment_method.is_a?(Spree::Gateway) && @payment.payment_method.payment_profiles_supported? && params[:card].present? and params[:card] != 'new'
+          @payment.source = CreditCard.find_by_id(params[:card])
+        end
+
+        begin
+          unless @payment.save
+            redirect_to admin_order_payments_path(@order)
+            return
+          end
+
+          if @order.completed?
+            @payment.process!
+            flash[:success] = flash_message_for(@payment, :successfully_created)
+
+             redirect_to admin_order_payments_path(@order)
+          else
+            #This is the first payment (admin created order)
+            until @order.completed?
+              @order.next!
+            end
+            flash[:success] = Spree.t(:new_order_completed)
+            redirect_to edit_admin_order_url(@order)
+          end
+
+        rescue Spree::Core::GatewayError => e
+          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[:payment]
+      end
+
+      def load_data
+        @amount = params[:amount] || load_order.total
+        @payment_methods = PaymentMethod.available
+        if @payment and @payment.payment_method
+          @payment_method = @payment.payment_method
+        else
+          @payment_method = @payment_methods.first
+        end
+        @previous_cards = @order.credit_cards.with_payment_profile
+      end
+
+      # At this point admin should have passed through Customer Details step
+      # where order.next is called which leaves the order in payment step
+      #
+      # Orders in complete step also allows to access this controller
+      #
+      # Otherwise redirect user to that step
+      def can_transition_to_payment
+        unless @order.payment? || @order.complete?
+          flash[:notice] = Spree.t(:fill_in_customer_info)
+          redirect_to edit_admin_order_customer_url(@order)
+        end
+      end
+
+      def load_order
+        @order = Order.find_by_number!(params[:order_id])
+        authorize! action, @order
+      end
+
+      def load_payment
+        @payment = Payment.find(params[:id])
+      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 => :permalink
+      before_filter :find_properties
+      before_filter :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

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

@@ -0,0 +1,115 @@
+module Spree
+  module Admin
+    class ProductsController < ResourceController
+      helper 'spree/products'
+
+      before_filter :load_data, :except => :index
+      create.before :create_before
+      update.before :update_before
+
+      def show
+        session[:return_to] ||= request.referer
+        redirect_to( :action => :edit )
+      end
+
+      def index
+        session[:return_to] = request.url
+        respond_with(@collection)
+      end
+
+      def update
+        if params[:product][:taxon_ids].present?
+          params[:product][:taxon_ids] = params[:product][:taxon_ids].split(',')
+        end
+        if params[:product][:option_type_ids].present?
+          params[:product][:option_type_ids] = params[:product][:option_type_ids].split(',')
+        end
+        super
+      end
+
+      def destroy
+        @product = Product.find_by_permalink!(params[:id])
+        @product.delete
+
+        flash[:success] = Spree.t('notice_messages.product_deleted')
+
+        respond_with(@product) do |format|
+          format.html { redirect_to collection_url }
+          format.js  { render_js_for_destroy }
+        end
+      end
+
+      def clone
+        @new = @product.duplicate
+
+        if @new.save
+          flash[:success] = Spree.t('notice_messages.product_cloned')
+        else
+          flash[:success] = Spree.t('notice_messages.product_not_cloned')
+        end
+
+        redirect_to edit_admin_product_url(@new)
+      end
+
+      def stock
+        @variants = @product.variants
+        @variants = [@product.master] if @variants.empty?
+        @stock_locations = StockLocation.accessible_by(current_ability, :read)
+      end
+
+      protected
+
+        def find_resource
+          Product.find_by_permalink!(params[:id])
+        end
+
+        def location_after_save
+          spree.edit_admin_product_url(@product)
+        end
+
+        def load_data
+          @taxons = Taxon.order(:name)
+          @option_types = OptionType.order(:name)
+          @tax_categories = TaxCategory.order(:name)
+          @shipping_categories = ShippingCategory.order(:name)
+        end
+
+        def collection
+          return @collection if @collection.present?
+          params[:q] ||= {}
+          params[:q][:deleted_at_null] ||= "1"
+
+          params[:q][:s] ||= "name asc"
+
+          @search = super.ransack(params[:q])
+          @collection = @search.result.
+            group_by_products_id.
+            includes(product_includes).
+            page(params[:page]).
+            per(Spree::Config[:admin_products_per_page])
+
+          if params[:q][:s].include?("master_default_price_amount")
+            # PostgreSQL compatibility
+            @collection = @collection.group("spree_prices.amount")
+          end
+          @collection
+        end
+
+        def create_before
+          return if params[:product][:prototype_id].blank?
+          @prototype = Spree::Prototype.find(params[:product][:prototype_id])
+        end
+
+        def update_before
+          # note: we only reset the product properties if we're receiving a post from the form on that tab
+          return unless params[:clear_product_properties]
+          params[:product] ||= {}
+        end
+
+        def product_includes
+         [{:variants => [:images, {:option_values => :option_type}]}, {:master => [:images, :default_price]}]
+        end
+
+    end
+  end
+end