spree_backend 2.0.0.rc1

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

@@ -0,0 +1,6 @@
+module Spree
+  module Admin
+    class TrackersController < ResourceController
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Spree
+  module Admin
+    class VariantsController < ResourceController
+      belongs_to 'spree/product', :find_by => :permalink
+      new_action.before :new_before
+
+      # override the destory method to set deleted_at value
+      # instead of actually deleting the product.
+      def destroy
+        @variant = Variant.find(params[:id])
+        @variant.deleted_at = Time.now()
+        if @variant.save
+          flash[:success] = Spree.t('notice_messages.variant_deleted')
+        else
+          flash[:success] = Spree.t('notice_messages.variant_not_deleted')
+        end
+
+        respond_with(@variant) do |format|
+          format.html { redirect_to admin_product_variants_url(params[:product_id]) }
+          format.js  { render_js_for_destroy }
+        end
+      end
+
+      protected
+        def new_before
+          @object.attributes = @object.product.master.attributes.except('id', 'created_at', 'deleted_at',
+                                                                        'sku', 'is_master')
+          # Shallow Clone of the default price to populate the price field.
+          @object.default_price = @object.product.master.default_price.clone
+        end
+
+        def collection
+          @deleted = (params.key?(:deleted) && params[:deleted] == "on") ? "checked" : ""
+
+          if @deleted.blank?
+            @collection ||= super
+          else
+            @collection ||= Variant.where(:product_id => parent.id).deleted
+          end
+          @collection
+        end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Spree
+  module Admin
+    class ZonesController < ResourceController
+      before_filter :load_data, :except => [:index]
+
+      def new
+        @zone.zone_members.build
+      end
+
+      protected
+
+        def collection
+          params[:q] ||= {}
+          params[:q][:s] ||= "ascend_by_name"
+          @search = super.ransack(params[:q])
+          @zones = @search.result.page(params[:page]).per(Spree::Config[:orders_per_page])
+        end
+
+        def load_data
+          @countries = Country.order(:name)
+          @states = State.order(:name)
+          @zones = Zone.order(:name)
+        end
+    end
+  end
+end

data/app/helpers/spree/admin/base_helper.rb

@@ -0,0 +1,168 @@
+module Spree
+  module Admin
+    module BaseHelper
+      def field_container(model, method, options = {}, &block)
+        css_classes = options[:class].to_a
+        css_classes << 'field'
+        if error_message_on(model, method).present?
+          css_classes << 'withError'
+        end
+        content_tag(:div, capture(&block), :class => css_classes.join(' '), :id => "#{model}_#{method}_field")
+      end
+
+      def error_message_on(object, method, options = {})
+        object = convert_to_model(object)
+        obj = object.respond_to?(:errors) ? object : instance_variable_get("@#{object}")
+
+        if obj && obj.errors[method].present?
+          errors = obj.errors[method].map { |err| h(err) }.join('<br />').html_safe
+          content_tag(:span, errors, :class => 'formError')
+        else
+          ''
+        end
+      end
+
+      def datepicker_field_value(date)
+        unless date.blank?
+          l(date, :format => Spree.t('date_picker.format'))
+        else
+          nil
+        end
+      end
+
+      # This method demonstrates the use of the :child_index option to render a
+      # form partial for, for instance, client side addition of new nested
+      # records.
+      #
+      # This specific example creates a link which uses javascript to add a new
+      # form partial to the DOM.
+      #
+      #   <%= form_for @project do |project_form| %>
+      #     <div id="tasks">
+      #       <%= project_form.fields_for :tasks do |task_form| %>
+      #         <%= render :partial => 'task', :locals => { :f => task_form } %>
+      #       <% end %>
+      #     </div>
+      #   <% end %>
+      def generate_html(form_builder, method, options = {})
+        options[:object] ||= form_builder.object.class.reflect_on_association(method).klass.new
+        options[:partial] ||= method.to_s.singularize
+        options[:form_builder_local] ||= :f
+
+        form_builder.fields_for(method, options[:object], :child_index => 'NEW_RECORD') do |f|
+          render(:partial => options[:partial], :locals => { options[:form_builder_local] => f })
+        end
+
+      end
+
+      def generate_template(form_builder, method, options = {})
+        escape_javascript generate_html(form_builder, method, options)
+      end
+
+      def remove_nested(fields)
+        out = ''
+        out << fields.hidden_field(:_destroy) unless fields.object.new_record?
+        out << (link_to icon('icon-remove'), "#", :class => 'remove')
+        out.html_safe
+      end
+
+      def preference_field_tag(name, value, options)
+        case options[:type]
+        when :integer
+          text_field_tag(name, value, preference_field_options(options))
+        when :boolean
+          hidden_field_tag(name, 0) +
+          check_box_tag(name, 1, value, preference_field_options(options))
+        when :string
+          text_field_tag(name, value, preference_field_options(options))
+        when :password
+          password_field_tag(name, value, preference_field_options(options))
+        when :text
+          text_area_tag(name, value, preference_field_options(options))
+        else
+          text_field_tag(name, value, preference_field_options(options))
+        end
+      end
+
+      def preference_field_for(form, field, options)
+        case options[:type]
+        when :integer
+          form.text_field(field, preference_field_options(options))
+        when :boolean
+          form.check_box(field, preference_field_options(options))
+        when :string
+          form.text_field(field, preference_field_options(options))
+        when :password
+          form.password_field(field, preference_field_options(options))
+        when :text
+          form.text_area(field, preference_field_options(options))
+        else
+          form.text_field(field, preference_field_options(options))
+        end
+      end
+
+      def preference_field_options(options)
+        field_options = case options[:type]
+        when :integer
+          { :size => 10,
+            :class => 'input_integer' }
+        when :boolean
+          {}
+        when :string
+          { :size => 10,
+            :class => 'input_string fullwidth' }
+        when :password
+          { :size => 10,
+            :class => 'password_string fullwidth' }
+        when :text
+          { :rows => 15,
+            :cols => 85,
+            :class => 'fullwidth' }
+        else
+          { :size => 10,
+            :class => 'input_string fullwidth' }
+        end
+
+        field_options.merge!({
+          :readonly => options[:readonly],
+          :disabled => options[:disabled],
+          :size     => options[:size]
+        })
+      end
+
+      def preference_fields(object, form)
+        return unless object.respond_to?(:preferences)
+        object.preferences.keys.map{ |key|
+
+          form.label("preferred_#{key}", Spree.t(key) + ": ") +
+            preference_field_for(form, "preferred_#{key}", :type => object.preference_type(key))
+
+        }.join("<br />").html_safe
+      end
+
+      def link_to_add_fields(name, target, options = {})
+        name = '' if options[:no_text]
+        css_classes = options[:class] ? options[:class] + " spree_add_fields" : "spree_add_fields"
+        link_to_with_icon('icon-plus', name, 'javascript:', :data => { :target => target }, :class => css_classes)
+      end
+
+      # renders hidden field and link to remove record using nested_attributes
+      def link_to_remove_fields(name, f, options = {})
+        name = '' if options[:no_text]
+        options[:class] = '' unless options[:class]
+        options[:class] += 'no-text with-tip' if options[:no_text]
+        url = f.object.persisted? ? [:admin, f.object] : '#'
+        link_to_with_icon('icon-trash', name, url, :class => "spree_remove_fields #{options[:class]}", :data => {:action => 'remove'}, :title => Spree.t(:remove)) + f.hidden_field(:_destroy)
+      end
+
+      def spree_dom_id(record)
+        dom_id(record, 'spree')
+      end
+
+      private
+        def attribute_name_for(field_name)
+          field_name.gsub(' ', '_').downcase
+        end
+    end
+  end
+end

data/app/helpers/spree/admin/general_settings_helper.rb

@@ -0,0 +1,13 @@
+module Spree
+  module Admin
+    module GeneralSettingsHelper
+      def currency_options
+        currencies = ::Money::Currency.table.map do |code, details|
+          iso = details[:iso_code]
+          [iso, "#{details[:name]} (#{iso})"]
+        end
+        options_from_collection_for_select(currencies, :first, :last, Spree::Config[:currency])
+      end
+    end
+  end
+end

data/app/helpers/spree/admin/inventory_settings_helper.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Admin
+    module InventorySettingsHelper
+      def show_not(true_or_false)
+        true_or_false ? '' : Spree.t(:not)
+      end
+    end
+  end
+end

data/app/helpers/spree/admin/navigation_helper.rb

@@ -0,0 +1,154 @@
+module Spree
+  module Admin
+    module NavigationHelper
+      # Make an admin tab that coveres one or more resources supplied by symbols
+      # Option hash may follow. Valid options are
+      #   * :label to override link text, otherwise based on the first resource name (translated)
+      #   * :route to override automatically determining the default route
+      #   * :match_path as an alternative way to control when the tab is active, /products would match /admin/products, /admin/products/5/variants etc.
+      def tab(*args)
+        options = {:label => args.first.to_s}
+
+        # Return if resource is found and user is not allowed to :admin
+        return '' if klass = klass_for(options[:label]) and cannot?(:admin, klass)
+
+        if args.last.is_a?(Hash)
+          options = options.merge(args.pop)
+        end
+        options[:route] ||=  "admin_#{args.first}"
+
+        destination_url = options[:url] || spree.send("#{options[:route]}_path")
+
+        titleized_label = Spree.t(options[:label], :default => options[:label]).titleize
+
+        css_classes = []
+
+        if options[:icon]
+          link = link_to_with_icon(options[:icon], titleized_label, destination_url)
+          css_classes << 'tab-with-icon'
+        else
+          link = link_to(titleized_label, destination_url)
+        end
+
+        selected = if options[:match_path]
+          request.fullpath.starts_with?("#{spree.root_path}admin#{options[:match_path]}")
+        else
+          args.include?(controller.controller_name.to_sym)
+        end
+        css_classes << 'selected' if selected
+
+        if options[:css_class]
+          css_classes << options[:css_class]
+        end
+        content_tag('li', link, :class => css_classes.join(' '))
+      end
+
+      # finds class for a given symbol / string
+      #
+      # Example :
+      # :products returns Spree::Product
+      # :my_products returns MyProduct if MyProduct is defined
+      # :my_products returns My::Product if My::Product is defined
+      # if cannot constantize it returns nil
+      # This will allow us to use cancan abilities on tab
+      def klass_for(name)
+        model_name = name.to_s
+
+        ["Spree::#{model_name.classify}", model_name.classify, model_name.gsub('_', '/').classify].find do |t|
+          t.safe_constantize
+        end.try(:safe_constantize)
+      end
+
+      def link_to_clone(resource, options={})
+        options[:data] = {:action => 'clone'}
+        link_to_with_icon('icon-copy', Spree.t(:clone), clone_admin_product_url(resource), options)
+      end
+
+      def link_to_new(resource)
+        options[:data] = {:action => 'new'}
+        link_to_with_icon('icon-plus', Spree.t(:new), edit_object_url(resource))
+      end
+
+      def link_to_edit(resource, options={})
+        options[:data] = {:action => 'edit'}
+        link_to_with_icon('icon-edit', Spree.t(:edit), edit_object_url(resource), options)
+      end
+
+      def link_to_edit_url(url, options={})
+        options[:data] = {:action => 'edit'}
+        link_to_with_icon('icon-edit', Spree.t(:edit), url, options)
+      end
+
+      def link_to_delete(resource, options={})
+        url = options[:url] || object_url(resource)
+        name = options[:name] || Spree.t(:delete)
+        options[:class] = "delete-resource"
+        options[:data] = { :confirm => Spree.t(:are_you_sure), :action => 'remove' }
+        link_to_with_icon 'icon-trash', name, url, options
+      end
+
+      def link_to_with_icon(icon_name, text, url, options = {})
+        options[:class] = (options[:class].to_s + " icon_link with-tip #{icon_name}").strip
+        options[:class] += ' no-text' if options[:no_text]
+        options[:title] = text if options[:no_text]
+        text = options[:no_text] ? '' : raw("<span class='text'>#{text}</span>")
+        options.delete(:no_text)
+        link_to(text, url, options)
+      end
+
+      def icon(icon_name)
+        icon_name ? content_tag(:i, '', :class => icon_name) : ''
+      end
+
+      def button(text, icon_name = nil, button_type = 'submit', options={})
+        button_tag(text, options.merge(:type => button_type, :class => "#{icon_name} button"))
+      end
+
+      def button_link_to(text, url, html_options = {})
+        if (html_options[:method] &&
+            html_options[:method].to_s.downcase != 'get' &&
+            !html_options[:remote])
+          form_tag(url, :method => html_options.delete(:method)) do
+            button(text, html_options.delete(:icon), nil, html_options)
+          end
+        else
+          if html_options['data-update'].nil? && html_options[:remote]
+            object_name, action = url.split('/')[-2..-1]
+            html_options['data-update'] = [action, object_name.singularize].join('_')
+          end
+
+          html_options.delete('data-update') unless html_options['data-update']
+
+          html_options[:class] = 'button'
+
+          if html_options[:icon]
+            html_options[:class] += " #{html_options[:icon]}"
+          end
+          link_to(text_for_button_link(text, html_options), url, html_options)
+        end
+      end
+
+      def text_for_button_link(text, html_options)
+        s = ''
+        s << text
+        raw(s)
+      end
+
+      def configurations_menu_item(link_text, url, description = '')
+        %(<tr>
+          <td>#{link_to(link_text, url)}</td>
+          <td>#{description}</td>
+        </tr>
+        ).html_safe
+      end
+
+      def configurations_sidebar_menu_item(link_text, url, options = {})
+        is_active = url.ends_with?(controller.controller_name) || url.ends_with?( "#{controller.controller_name}/edit")
+        options.merge!(:class => is_active ? 'active' : nil)
+        content_tag(:li, options) do
+          link_to(link_text, url)
+        end
+      end
+    end
+  end
+end

data/app/helpers/spree/admin/orders_helper.rb

@@ -0,0 +1,19 @@
+module Spree
+  module Admin
+    module OrdersHelper
+      # Renders all the extension partials that may have been specified in the extensions
+      def event_links
+        links = []
+        @order_events.sort.each do |event|
+          if @order.send("can_#{event}?")
+            links << button_link_to(Spree.t(event), fire_admin_order_url(@order, :e => event),
+                                    :method => :put,
+                                    :icon => "icon-#{event}",
+                                    :data => { :confirm => Spree.t(:order_sure_want_to, :event => Spree.t(event)) })
+          end
+        end
+        links.join('&nbsp;').html_safe
+      end
+    end
+  end
+end