MyCommerceapi 1.0.0

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

@@ -0,0 +1,51 @@
+class Admin::VariantsController < Admin::ResourceController
+  belongs_to :product, :find_by => :permalink
+  create.before :create_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.notice = I18n.t("notice_messages.variant_deleted")
+    else
+      flash.notice = I18n.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
+
+  def update_positions
+    params[:positions].each do |id, index|
+      Variant.update_all(['position=?', index], ['id=?', id])
+    end
+
+    respond_with(@variant) do |format|
+      format.html { redirect_to admin_product_variants_url(params[:product_id]) }
+      format.js  { render :text => 'Ok' }
+    end
+  end
+
+  protected
+  def create_before
+    option_values = params[:new_variant]
+    option_values.each_value {|id| @object.option_values << OptionValue.find(id)}
+    @object.save
+  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

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

@@ -0,0 +1,23 @@
+class Admin::ZonesController < Admin::ResourceController
+  before_filter :load_data, :except => [:index]
+
+  def new
+    @zone.zone_members.build
+    respond_with(@zone)
+  end
+
+  protected
+
+  def collection
+    params[:search] ||= {}
+    params[:search][:meta_sort] ||= "ascend_by_name"
+    @search = super.metasearch(params[:search])
+    @zones = @search.paginate(:per_page => Spree::Config[:orders_per_page], :page => params[:page])
+  end
+
+  def load_data
+    @countries = Country.order(:name)
+    @states = State.order(:name)
+    @zones = Zone.order(:name)
+  end
+end

data/core/app/controllers/checkout_controller.rb

@@ -0,0 +1,97 @@
+# Handles checkout logic.  This is somewhat contrary to standard REST convention since there is not actually a
+# Checkout object.  There's enough distinct logic specific to checkout which has nothing to do with updating an
+# order that this approach is waranted.
+class CheckoutController < Spree::BaseController
+  ssl_required
+
+  before_filter :load_order
+  rescue_from Spree::GatewayError, :with => :rescue_from_spree_gateway_error
+
+  respond_to :json
+
+  # Updates the order and advances to the next state (when possible.)
+  def update
+    if @order.update_attributes(object_params)
+      if @order.next
+        state_callback(:after)
+      else
+        flash[:error] = I18n.t(:payment_processing_failed)
+        #respond_with(@order, :location => checkout_state_path(@order.state))
+        render :json => @order.to_json, :status => 201
+        return
+      end
+
+      if @order.state == "complete" || @order.completed?
+        flash[:notice] = I18n.t(:order_processed_successfully)
+        flash[:commerce_tracking] = "nothing special"
+        #respond_with(@order, :location => completion_route)
+        render :json => @order.to_json, :status => 201,:location => completion_route
+      else
+        #respond_with(@order, :location => checkout_state_path(@order.state))
+        render :json => @order.to_json, :status => 201,:location=>checkout_state_path(@order.state)
+      end
+    else
+      #respond_with(@order) { |format| format.html { render :edit } }
+      render :json => @order.to_json, :status => 201
+    end
+  end
+
+  private
+
+  # Provides a route to redirect after order completion
+  def completion_route
+    order_path(@order)
+  end
+
+  def object_params
+    # For payment step, filter order parameters to produce the expected nested attributes for a single payment and its source, discarding attributes for payment methods other than the one selected
+    if @order.payment?
+      if params[:payment_source].present? && source_params = params.delete(:payment_source)[params[:order][:payments_attributes].first[:payment_method_id].underscore]
+        params[:order][:payments_attributes].first[:source_attributes] = source_params
+      end
+      if (params[:order][:payments_attributes])
+        
+        params[:order][:payments_attributes].first[:amount] = @order.total
+      end
+    end
+    params[:order]
+  end
+
+  def load_order
+    @order = current_order
+    redirect_to cart_path and return unless @order and @order.checkout_allowed?
+    redirect_to cart_path and return if @order.completed?
+    @order.state = params[:state] if params[:state]
+    state_callback(:before)
+  end
+
+  def state_callback(before_or_after = :before)
+    method_name = :"#{before_or_after}_#{@order.state}"
+    p method_name
+    send(method_name) if respond_to?(method_name, true)
+  end
+
+  def before_address
+    @order.bill_address ||= Address.default
+    @order.ship_address ||= Address.default
+  end
+
+  def before_delivery
+    return if params[:order].present?
+    @order.shipping_method ||= (@order.rate_hash.first && @order.rate_hash.first[:shipping_method])
+  end
+
+  def before_payment
+    current_order.payments.destroy_all if request.put?
+  end
+
+  def after_complete
+    session[:order_id] = nil
+  end
+
+  def rescue_from_spree_gateway_error
+    flash[:error] = t('spree_gateway_error_flash_for_checkout')
+    render :edit
+  end
+
+end

data/core/app/controllers/content_controller.rb

@@ -0,0 +1,21 @@
+class ContentController < Spree::BaseController
+  # Don't serve local files or static assets
+  before_filter { render_404 if params[:path] =~ /(\.|\\)/ }
+
+  rescue_from ActionView::MissingTemplate, :with => :render_404
+  caches_page :show, :index, :if => Proc.new { Spree::Config[:cache_static_content] }
+
+  respond_to :html
+
+  def show
+    respond_with do |format|
+      format.html { render :template => params[:path] }
+    end
+  end
+
+  def cvv
+    respond_with do |format|
+      format.html {  render "cvv", :layout => false }
+    end
+  end
+end

data/core/app/controllers/locale_controller.rb

@@ -0,0 +1,14 @@
+class LocaleController < Spree::BaseController
+  def set
+    if request.referer && request.referer.starts_with?("http://" + request.host)
+      session["user_return_to"] = request.referer
+    end
+    if params[:locale] && I18n.available_locales.include?(params[:locale].to_sym)
+      session[:locale] = I18n.locale = params[:locale].to_sym
+      flash.notice = t(:locale_changed)
+    else
+      flash[:error] = t(:locale_not_changed)
+    end
+    redirect_back_or_default(root_path)
+  end
+end

data/core/app/controllers/orders_controller.rb

@@ -0,0 +1,64 @@
+class OrdersController < Spree::BaseController
+  respond_to :html
+
+  helper :products
+
+
+  def show
+    @order = Order.find_by_number(params[:id])
+  end
+
+  def update
+    @order = current_order
+    if @order.update_attributes(params[:order])
+      @order.line_items = @order.line_items.select {|li| li.quantity > 0 }
+      respond_with(@order) { |format| format.html { redirect_to cart_path } }
+    else
+      respond_with(@order) 
+    end
+  end
+
+  # Shows the current incomplete order from the session
+  def edit
+    @order = current_order(true)
+  end
+
+  # Adds a new item to the order (creating a new order if none already exists)
+  #
+  # Parameters can be passed using the following possible parameter configurations:
+  #
+  # * Single variant/quantity pairing
+  # +:variants => {variant_id => quantity}+
+  #
+  # * Multiple products at once
+  # +:products => {product_id => variant_id, product_id => variant_id}, :quantity => quantity +
+  # +:products => {product_id => variant_id, product_id => variant_id}}, :quantity => {variant_id => quantity, variant_id => quantity}+
+  def populate
+    @order = current_order(true)
+
+    params[:products].each do |product_id,variant_id|
+      quantity = params[:quantity].to_i if !params[:quantity].is_a?(Hash)
+      quantity = params[:quantity][variant_id].to_i if params[:quantity].is_a?(Hash)
+      @order.add_variant(Variant.find(variant_id), quantity) if quantity > 0
+    end if params[:products]
+
+    params[:variants].each do |variant_id, quantity|
+      quantity = quantity.to_i
+      @order.add_variant(Variant.find(variant_id), quantity) if quantity > 0
+    end if params[:variants]
+
+    respond_with(@order) { |format| format.html { redirect_to cart_path } }
+  end
+
+  def empty
+    if @order = current_order
+      @order.line_items.destroy_all
+    end
+    
+    respond_with(@order) { |format| format.html { redirect_to cart_path } }
+  end
+
+  def accurate_title
+    @order && @order.completed? ? "#{Order.human_name} #{@order.number}" : I18n.t(:shopping_cart)
+  end
+end

data/core/app/controllers/products_controller.rb

@@ -0,0 +1,39 @@
+class ProductsController < Spree::BaseController
+  HTTP_REFERER_REGEXP = /^https?:\/\/[^\/]+\/t\/([a-z0-9\-\/]+)$/
+  rescue_from ActiveRecord::RecordNotFound, :with => :render_404
+  helper :taxons
+
+  respond_to :html
+
+  def index
+    @searcher = Spree::Config.searcher_class.new(params)
+    @products = @searcher.retrieve_products
+    @new_sales=Product.where("available_on=?",Date.today-5.days)
+    @coming_soon=Product.where("available_on > ? and deleted_at is NULL",Date.today)
+    respond_with(@products)
+  end
+
+  def show
+    @product = Product.find_by_permalink!(params[:id])
+    return unless @product
+
+    @variants = Variant.active.includes([:option_values, :images]).where(:product_id => @product.id)
+    @product_properties = ProductProperty.includes(:property).where(:product_id => @product.id)
+    @selected_variant = @variants.detect { |v| v.available? }
+
+    referer = request.env['HTTP_REFERER']
+
+    if referer && referer.match(HTTP_REFERER_REGEXP)
+      @taxon = Taxon.find_by_permalink($1)
+    end
+
+    respond_with(@product)
+  end
+
+  private
+
+  def accurate_title
+    @product ? @product.name : super
+  end
+  
+ end

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

@@ -0,0 +1,4 @@
+class Spree::BaseController < ActionController::Base
+  include SpreeBase
+  include SpreeRespondWith
+end

data/core/app/controllers/states_controller.rb

@@ -0,0 +1,16 @@
+class StatesController < Spree::BaseController
+
+  ssl_allowed :index
+
+  def index
+    # table of {country.id => [ state.id , state.name ]}, arrays sorted by name
+    # blank is added elsewhere, if needed
+    # we return ALL known information, since billing country isn't restricted
+    #   by shipping country
+    @state_info = Hash.new {|h, k| h[k] = []}
+    State.order("name ASC").each{|state|
+      @state_info[state.country_id.to_s].push [state.id, state.name]
+    }
+  end
+
+end

data/core/app/controllers/taxons_controller.rb

@@ -0,0 +1,22 @@
+class TaxonsController < Spree::BaseController
+  rescue_from ActiveRecord::RecordNotFound, :with => :render_404
+  helper :products
+
+  respond_to :html
+
+  def show
+    @taxon = Taxon.find_by_permalink!(params[:id])
+    return unless @taxon
+
+    @searcher = Spree::Config.searcher_class.new(params.merge(:taxon => @taxon.id))
+    @products = @searcher.retrieve_products
+
+    respond_with(@taxon)
+  end
+
+  private
+
+  def accurate_title
+    @taxon ? @taxon.name : super
+  end
+end

data/core/app/helpers/account_helper.rb

@@ -0,0 +1,2 @@
+module AccountHelper
+end

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

@@ -0,0 +1,194 @@
+module Admin::BaseHelper
+
+  def field_container(model, method, options = {}, &block)
+    unless error_message_on(model, method).blank?
+      css_class = 'withError'
+    end
+    content_tag('p', capture(&block), :class => css_class)
+  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 spree_date_picker(object, method, options = {}, html_options = {})
+    options.merge!(:format => "y-m-d")
+    unobtrusive_date_text_picker(object, method, options, html_options)
+  end
+
+  def class_for_error(model, method)
+    if error_message_on :product, :name
+    end
+  end
+
+  #You can add additional_fields to the product and variant models. See section 4.2 here: http://spreecommerce.com/documentation/extensions.html
+  #If you do choose to add additional_fields, you can utilize the :use parameter to set the input type for any such fields. For example, :use => 'check_box'
+  #In the event that you add this functionality, the following method takes care of rendering the proper input type and logic for the supported input-types, which are text_field, check_box, radio_button, and select.
+  def get_additional_field_value(controller, field)
+    attribute = attribute_name_for(field[:name])
+
+    value = eval("@" + controller.controller_name.singularize + "." + attribute)
+
+    if value.nil? && controller.controller_name == "variants"
+      value = @variant.product.has_attribute?(attribute) ? @variant.product[attribute] : nil
+    end
+
+    if value.nil?
+      return value
+    else
+      return field.key?(:format) ? sprintf(field[:format], value) : value
+    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("delete"), "#", :class => "remove")
+    out.html_safe
+  end
+
+  def preference_field(form, field, options)
+    case options[:type]
+    when :integer
+      form.text_field(field, {
+          :size => 10,
+          :class => 'input_integer',
+          :readonly => options[:readonly],
+          :disabled => options[:disabled]
+        }
+      )
+    when :boolean
+      form.check_box(field, {:readonly => options[:readonly],
+          :disabled => options[:disabled]})
+    when :string
+      form.text_field(field, {
+          :size => 10,
+          :class => 'input_string',
+          :readonly => options[:readonly],
+          :disabled => options[:disabled]
+        }
+      )
+    when :password
+      form.password_field(field, {
+          :size => 10,
+          :class => 'password_string',
+          :readonly => options[:readonly],
+          :disabled => options[:disabled]
+        }
+      )
+    when :text
+      form.text_area(field,
+        {:rows => 15, :cols => 85, :readonly => options[:readonly],
+          :disabled => options[:disabled]}
+      )
+    else
+      form.text_field(field, {
+          :size => 10,
+          :class => 'input_string',
+          :readonly => options[:readonly],
+          :disabled => options[:disabled]
+        }
+      )
+    end
+  end
+
+  def preference_fields(object, form)
+    return unless object.respond_to?(:preferences)
+    object.preferences.keys.map{ |key|
+      next unless object.class.preference_definitions.has_key? key
+
+      definition = object.class.preference_definitions[key]
+      type = definition.instance_eval{@type}.to_sym
+
+      form.label("preferred_#{key}", t(key)+": ") +
+        preference_field(form, "preferred_#{key}", :type => type)
+    }.join("<br />").html_safe
+  end
+
+  def additional_field_for(controller, field)
+     field[:use] ||= 'text_field'
+     options = field[:options] || {}
+
+     object_name, method = controller.controller_name.singularize, attribute_name_for(field[:name])
+
+     case field[:use]
+     when 'check_box'
+       check_box(object_name, method, options, field[:checked_value] || 1, field[:unchecked_value] || 0)
+     when 'radio_button'
+       html = ''
+       field[:value].call(controller, field).each do |value|
+         html << radio_button(object_name, method, value, options)
+         html << " #{value.to_s} "
+       end
+       html
+     when 'select'
+       select(object_name, method, field[:value].call(controller, field), options, field[:html_options] || {})
+     else
+       value = field[:value] ? field[:value].call(controller, field) : get_additional_field_value(controller, field)
+       __send__(field[:use], object_name, method, options.merge(:value => value))
+     end # case
+   end
+
+  def product_picker_field(name, value)
+    products = Product.with_ids(value)
+    product_names_hash = products.inject({}){|memo,item| memo[item.id] = item.name; memo}
+    %(<input type="text" name="#{name}" value="#{value}" class="tokeninput products" data-names='#{product_names_hash.to_json}' />).html_safe
+  end
+
+  # renders set of hidden fields and button to add new record using nested_attributes
+  def link_to_add_fields(name, append_to_selector, f, association)
+    new_object = f.object.class.reflect_on_association(association).klass.new
+    fields = f.fields_for(association, new_object, :child_index => "new_#{association}") do |builder|
+      render(association.to_s.singularize + "_fields", :f => builder)
+    end
+    link_to_function(name, raw("add_fields(\"#{append_to_selector}\", \"#{association}\", \"#{escape_javascript(fields)}\")"), :class => 'add_fields')
+  end
+
+  # renders hidden field and link to remove record using nested_attributes
+  def link_to_remove_fields(name, f)
+    f.hidden_field(:_destroy) + link_to_with_icon(:delete, name, '#', :class => 'remove_fields')
+  end
+
+  private
+  def attribute_name_for(field_name)
+    field_name.gsub(' ', '_').downcase
+  end
+
+end