apispree_core 0.0.0

data/app/helpers/admin/orders_helper.rb

@@ -0,0 +1,22 @@
+module Admin::OrdersHelper
+
+  # Renders all the txn partials that may have been specified in the extensions
+  def render_txn_partials(order)
+    @txn_partials.inject("") do |extras, partial|
+      extras += render :partial => partial, :locals => {:payment => order}
+    end
+  end
+
+  # 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(t(event), fire_admin_order_url(@order, :e => event),
+                                { :method => :put, :confirm => t("order_sure_want_to", :event => t(event)) })
+      end
+    end
+    links.join('&nbsp;').html_safe
+  end
+
+end

data/app/helpers/admin/overview_helper.rb

@@ -0,0 +1,12 @@
+module Admin::OverviewHelper
+  def render_ordes(orders, later=false)
+    text = []
+    if orders.any?
+      # TODO: handle Order objects, create partials for this
+      # orders.each_with_index {|order, i| text << render(:partial => "#{order.mode}_event", :locals => {:order => order, :shaded => (i % 2 > 0), :later => later}) }
+    else
+      text << %w(<li class="order-none shade">No orders</li>)
+    end
+    %(<ul class="orders">#{text.join}</ul>)
+  end
+end

data/app/helpers/admin/payments_helper.rb

@@ -0,0 +1,7 @@
+module Admin::PaymentsHelper
+  def payment_method_name(payment)
+    # hack to allow us to retrieve the name of a "deleted" payment method
+    id = payment.payment_method_id
+    PaymentMethod.find_with_destroyed(id).name
+  end
+end

data/app/helpers/admin/product_groups_helper.rb

@@ -0,0 +1,11 @@
+module Admin::ProductGroupsHelper
+
+  # Allow certain scope attributes to have a custom field type
+  def product_scope_field(product_scope, i)
+    value = (product_scope.arguments || [])[i]
+    name = "product_group[product_scopes_attributes][][arguments][]"
+    helper_method_for_scope = Scopes::Product::ATTRIBUTE_HELPER_METHODS[product_scope.name.to_sym] || :text_field_tag
+    send(helper_method_for_scope, name, value)
+  end
+
+end

data/app/helpers/admin/product_properties_helper.rb

@@ -0,0 +1,21 @@
+module Admin::ProductPropertiesHelper
+
+  # Generates the appropriate field name for attribute_fu.  Normally attribute_fu handles this but we've got a
+  # special case where we need text_field_with_autocomplete and we have to recreate attribute_fu's naming
+  # scheme manually.
+  def property_fu_name(product_property, number)
+    if product_property.new_record?
+      "product[product_property_attributes][new][#{number}][property_name]"
+    else
+      "product[product_property_attributes][#{product_property.id}][property_name]"
+    end
+  end
+
+  def property_fu_value(product_property, number)
+    if product_property.new_record?
+      "product[product_property_attributes][new][#{number}][value]"
+    else
+      "product[product_property_attributes][#{product_property.id}][value]"
+    end
+  end
+end

data/app/helpers/admin/products_helper.rb

@@ -0,0 +1,11 @@
+module Admin::ProductsHelper
+  def option_type_select(so)
+    select(:new_variant,
+           so.option_type.presentation,
+           so.option_type.option_values.collect {|ov| [ ov.presentation, ov.id ] })
+  end
+
+  def pv_tag_id(product_value)
+    "product-property-value-#{product_value.id}"
+  end
+end

data/app/helpers/admin/taxons_helper.rb

@@ -0,0 +1,18 @@
+module Admin::TaxonsHelper
+  def taxon_path(taxon)
+    taxon.ancestors.reverse.collect { |ancestor| ancestor.name }.join( " >> ")
+  end
+  
+  def taxons_checkbox_tree(root, product)
+    return '' if root.children.blank?
+    content_tag 'ul' do
+      root.children.map do |taxon|
+        content_tag 'li' do
+          [check_box_tag("taxon_ids[]", taxon.id, product.taxons.include?(taxon), :id => "taxon_ids_#{taxon.id}"),
+           label_tag("taxon_ids_#{taxon.id}", taxon.name)].join(' ').html_safe +
+          taxons_checkbox_tree(taxon, product)
+        end.html_safe
+      end.join("\n").html_safe
+    end
+  end
+end

data/app/helpers/admin/users_helper.rb

@@ -0,0 +1,8 @@
+module Admin::UsersHelper
+
+  def list_roles(user)
+    # while testing spree-core itself user model does not have method roles
+    user.respond_to?(:roles) ? user.roles.collect {|role| role.name}.join(", ") : []
+  end
+
+end

data/app/helpers/admin/zones_helper.rb

@@ -0,0 +1,11 @@
+module Admin::ZonesHelper
+  def country_checked
+    return object.kind == "country" ? "checked = 'true'" : ""
+  end
+  def state_checked
+    return object.kind == "state" ? "checked = 'true'" : ""
+  end
+  def zone_checked
+    return object.kind == "zone" ? "checked = 'true'" : ""
+  end
+end

data/app/helpers/checkout_helper.rb

@@ -0,0 +1,31 @@
+module CheckoutHelper
+
+  def checkout_progress
+    if Gateway.current and Gateway.current.payment_profiles_supported?
+      states = %w(address delivery payment confirm complete)
+    else
+      states = %w(address delivery payment complete)
+    end
+    items = states.map do |state|
+      text = t("order_state.#{state}").titleize
+
+      css_classes = []
+      current_index = states.index(@order.state)
+      state_index = states.index(state)
+
+      if state_index < current_index
+        css_classes << 'completed'
+        text = link_to text, checkout_state_path(state)
+      end
+
+      css_classes << 'next' if state_index == current_index + 1
+      css_classes << 'current' if state == @order.state
+      css_classes << 'first' if state_index == 0
+      css_classes << 'last' if state_index == states.length - 1
+      # It'd be nice to have separate classes but combining them with a dash helps out for IE6 which only sees the last class
+      content_tag('li', content_tag('span', text), :class => css_classes.join('-'))
+    end
+    content_tag('ol', raw(items.join("\n")), :class => 'progress-steps', :id => "checkout-step-#{@order.state}")
+  end
+
+end

data/app/helpers/hook_helper.rb

@@ -0,0 +1,20 @@
+module HookHelper
+
+  # Allow hooks to be used in views like this:
+  #
+  #   <%= hook :some_hook %>
+  #
+  #   <%= hook :some_hook do %>
+  #     <p>Some HTML</p>
+  #   <% end %>
+  #
+  def hook(hook_name, locals = {}, &block)
+    content = block_given? ? capture(&block) : ''
+    Spree::ThemeSupport::Hook.render_hook(hook_name, content, self, locals)
+  end
+
+  def locals_hash(names, binding)
+    names.inject({}) {|memo, key| memo[key.to_sym] = eval(key, binding); memo}
+  end
+
+end

data/app/helpers/orders_helper.rb

@@ -0,0 +1,3 @@
+module OrdersHelper
+
+end

data/app/helpers/products_helper.rb

@@ -0,0 +1,30 @@
+module ProductsHelper
+  # returns the formatted change in price (from the master price) for the specified variant (or simply return
+  # the variant price if no master price was supplied)
+  def variant_price_diff(variant)
+    return product_price(variant) unless variant.product.master.price
+    diff = product_price(variant, :format_as_currency => false) - product_price(variant.product, :format_as_currency => false)
+    return nil if diff == 0
+    if diff > 0
+      "(#{t("add")}: #{format_price diff.abs})"
+    else
+      "(#{t("subtract")}: #{format_price diff.abs})"
+    end
+  end
+
+  # returns the price of the product to show for display purposes
+  def product_price(product_or_variant, options={})
+    options.assert_valid_keys(:format_as_currency, :show_vat_text)
+    options.reverse_merge! :format_as_currency => true, :show_vat_text => Spree::Config[:show_price_inc_vat]
+
+    amount = product_or_variant.price
+    amount += Calculator::Vat.calculate_tax_on(product_or_variant) if Spree::Config[:show_price_inc_vat]
+    options.delete(:format_as_currency) ? format_price(amount, options) : amount
+  end
+
+  # converts line breaks in product description into <p> tags (for html display purposes)
+  def product_description(product)
+    raw(product.description.gsub(/^(.*)$/, '<p>\1</p>'))
+  end
+
+end

data/app/helpers/search_helper.rb

@@ -0,0 +1,10 @@
+module SearchHelper
+  def search_options
+    options = {}
+    return options if params[:search].nil?
+    params[:search].each do |name, value|
+      options["search[#{name}]"] = value
+    end
+    options
+  end
+end

data/app/helpers/spree/base_helper.rb

@@ -0,0 +1,119 @@
+module Spree::BaseHelper
+
+  def link_to_cart(text = t('cart'))
+    return "" if current_page?(cart_path)
+    css_class = nil
+    if current_order.nil? or current_order.line_items.empty?
+      text = "#{text}: (#{t('empty')})"
+      css_class = 'empty'
+    else
+      text = "#{text}: (#{current_order.item_count}) #{order_price(current_order)}"
+      css_class = 'full'
+    end
+    link_to text, cart_path, :class => css_class
+  end
+
+  def order_price(order, options={})
+    options.assert_valid_keys(:format_as_currency, :show_vat_text, :show_price_inc_vat)
+    options.reverse_merge! :format_as_currency => true, :show_vat_text => true
+
+    # overwrite show_vat_text if show_price_inc_vat is false
+    options[:show_vat_text] = Spree::Config[:show_price_inc_vat]
+
+    amount =  order.item_total
+    amount += Calculator::Vat.calculate_tax(order) if Spree::Config[:show_price_inc_vat]
+
+    options.delete(:format_as_currency) ? number_to_currency(amount) : amount
+  end
+
+  def todays_short_date
+    utc_to_local(Time.now.utc).to_ordinalized_s(:stub)
+  end
+
+  def yesterdays_short_date
+    utc_to_local(Time.now.utc.yesterday).to_ordinalized_s(:stub)
+  end
+
+  # human readable list of variant options
+  def variant_options(v, allow_back_orders = Spree::Config[:allow_backorders], include_style = true)
+    list = v.options_text
+    list = include_style ? "<span class =\"out-of-stock\">(" + t("out_of_stock") + ") #{list}</span>" : "#{t("out_of_stock")} #{list}" unless (allow_back_orders || v.in_stock?)
+    list
+  end
+
+  Image.attachment_definitions[:attachment][:styles].each do |style, v|
+    define_method "#{style}_image" do |product, *options|
+      options = options.first || {}
+      if product.images.empty?
+        image_tag "noimage/#{style}.jpg", options
+      else
+        image = product.images.first
+        options.reverse_merge! :alt => image.alt.blank? ? product.name : image.alt
+        image_tag image.attachment.url(style), options
+      end
+    end
+  end
+
+  def meta_data_tags
+    object = instance_variable_get('@'+controller_name.singularize)
+    return unless object
+    "".tap do |tags|
+      if object.respond_to?(:meta_keywords) and object.meta_keywords.present?
+        tags << tag('meta', :name => 'keywords', :content => object.meta_keywords) + "\n"
+      end
+      if object.respond_to?(:meta_description) and object.meta_description.present?
+        tags << tag('meta', :name => 'description', :content => object.meta_description) + "\n"
+      end
+    end
+  end
+
+  def stylesheet_tags(paths=stylesheet_paths)
+    paths.blank? ? '' : stylesheet_link_tag(paths, :cache => true)
+  end
+
+  def stylesheet_paths
+    paths = Spree::Config[:stylesheets]
+    if (paths.blank?)
+      []
+    else
+      paths.split(',')
+    end
+  end
+
+  def logo(image_path=Spree::Config[:logo])
+    link_to image_tag(image_path), root_path
+  end
+
+  def available_countries
+    return Country.all unless zone = Zone.find_by_name(Spree::Config[:checkout_zone])
+    zone.country_list
+  end
+  
+  def format_price(price, options={})
+    options.assert_valid_keys(:show_vat_text)
+    options.reverse_merge! :show_vat_text => Spree::Config[:show_price_inc_vat]
+    formatted_price = number_to_currency(price)
+    if options[:show_vat_text]
+      I18n.t(:price_with_vat_included, :price => formatted_price)
+    else
+      formatted_price
+    end
+  end
+  
+  # generates nested url to product based on supplied taxon
+  def seo_url(taxon, product = nil)
+    return '/t/' + taxon.permalink if product.nil?
+    warn "DEPRECATION: the /t/taxon-permalink/p/product-permalink urls are "+
+      "not used anymore. Use product_url instead. (called from #{caller[0]})"
+    return product_url(product)
+  end
+  
+  def current_orders_product_count
+    if current_order.blank? || current_order.item_count < 1
+      return 0
+    else
+      return current_order.item_count
+    end
+  end
+
+end

data/app/helpers/taxons_helper.rb

@@ -0,0 +1,32 @@
+module TaxonsHelper
+  def breadcrumbs(taxon, separator=" » ")
+    return "" if current_page?("/")
+    separator = raw(separator)
+    crumbs = [content_tag(:li, link_to(t(:home) , root_path) + separator)]
+    if taxon
+      crumbs << content_tag(:li, link_to(t('products') , products_path) + separator)
+      crumbs << taxon.ancestors.collect { |ancestor| content_tag(:li, link_to(ancestor.name , seo_url(ancestor)) + separator) } unless taxon.ancestors.empty?
+      crumbs << content_tag(:li, content_tag(:span, taxon.name))
+    else
+      crumbs << content_tag(:li, content_tag(:span, t('products')))
+    end
+    crumb_list = content_tag(:ul, raw(crumbs.flatten.map{|li| li.mb_chars}.join))
+    content_tag(:div, crumb_list + tag(:br, {:class => 'clear'}, false, true), :class => 'breadcrumbs')
+  end
+
+
+  # Retrieves the collection of products to display when "previewing" a taxon.  This is abstracted into a helper so
+  # that we can use configurations as well as make it easier for end users to override this determination.  One idea is
+  # to show the most popular products for a particular taxon (that is an exercise left to the developer.)
+  def taxon_preview(taxon, max=4)
+    products = taxon.active_products.limit(max)
+    if (products.size < max) && Spree::Config[:show_descendents]
+      taxon.descendants.each do |taxon|
+        to_get = max - products.length
+        products += taxon.active_products.limit(to_get)
+        break if products.size >= max
+      end
+    end
+    products
+  end
+end

data/app/helpers/trackers_helper.rb

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

data/app/mailers/order_mailer.rb

@@ -0,0 +1,19 @@
+class OrderMailer < ActionMailer::Base
+  helper "spree/base"
+
+  def confirm_email(order, resend=false)
+    @order = order
+    subject = (resend ? "[RESEND] " : "")
+    subject += "#{Spree::Config[:site_name]} #{t('subject', :scope =>'order_mailer.confirm_email')} ##{order.number}"
+    mail(:to => order.email,
+         :subject => subject)
+  end
+
+  def cancel_email(order, resend=false)
+    @order = order
+    subject = (resend ? "[RESEND] " : "")
+    subject += "#{Spree::Config[:site_name]} #{t('subject', :scope => 'order_mailer.cancel_email')} ##{order.number}"
+    mail(:to => order.email,
+         :subject => subject)
+  end
+end

data/app/mailers/shipment_mailer.rb

@@ -0,0 +1,11 @@
+class ShipmentMailer < ActionMailer::Base
+  helper "spree/base"
+
+  def shipped_email(shipment, resend=false)
+    @shipment = shipment
+    subject = (resend ? "[RESEND] " : "")
+    subject += "#{Spree::Config[:site_name]} #{t('subject', :scope => 'shipment_mailer.shipped_email')} ##{shipment.order.number}"
+    mail(:to => shipment.order.email,
+         :subject => subject)
+  end
+end

data/app/models/address.rb

@@ -0,0 +1,115 @@
+class Address < ActiveRecord::Base
+  belongs_to :country
+  belongs_to :state
+
+  has_many :shipments
+
+  validates :firstname, :lastname, :address1, :city, :zipcode, :country, :phone, :presence => true
+  validate :state_validate
+
+  # disconnected since there's no code to display error messages yet OR matching client-side validation
+  def phone_validate
+    return if phone.blank?
+    n_digits = phone.scan(/[0-9]/).size
+    valid_chars = (phone =~ /^[-+()\/\s\d]+$/)
+    if !(n_digits > 5 && valid_chars)
+      errors.add(:phone, :invalid)
+    end
+  end
+
+  def state_validate
+    #skip state validation without country (also required)
+    #or when disabled by perfernce
+    return if self.country_id.blank? || !Spree::Config[:address_requires_state]
+
+    #ensure associated state belongs to country
+    if self.state_id.present?
+      if self.state.country_id == self.country_id
+
+          self.state_name = nil #not required as we have a valid state and country combo
+      else
+        if self.state_name.present?
+
+          self.state_id = nil
+        else
+          errors.add(:state, :invalid)
+        end
+      end
+    end
+
+    #ensure state_name belongs to country without states, or that it matches a predefined state name/abbr
+    if self.state_name.present?
+      country = Country.where(:id => self.country_id).try(:first)
+
+      if country.states.present?
+        states = country.states.where(["name = ? OR abbr = ?",self.state_name, self.state_name])
+
+        if states.size == 1
+          self.state = states.first
+          self.state_name = nil
+        else
+          errors.add(:state, :invalid)
+        end
+      end
+    end
+
+    #ensure at least one state field is populated
+    if self.state_id.blank? && self.state_name.blank?
+      errors.add(:state, :blank)
+    end
+
+  end
+
+  def self.default
+    new :country_id => Spree::Config[:default_country_id]
+  end
+
+  # can modify an address if it's not been used in an order (but checkouts controller has finer control)
+  # def editable?
+  #   new_record? || (shipments.empty? && checkouts.empty?)
+  # end
+
+  def full_name
+    self.firstname + " " + self.lastname
+  end
+
+  def state_text
+    state.nil? ? state_name : (state.abbr.blank? ? state.name : state.abbr)
+  end
+
+  def zone
+    (state && state.zone) ||
+    (country && country.zone)
+  end
+
+  def zones
+    Zone.match(self)
+  end
+
+  def same_as?(other)
+    return false if other.nil?
+    attributes.except("id", "updated_at", "created_at") ==  other.attributes.except("id", "updated_at", "created_at")
+  end
+  alias same_as same_as?
+
+  def to_s
+    "#{full_name}: #{address1}"
+  end
+
+  def clone
+    Address.new(self.attributes.except("id", "updated_at", "created_at"))
+  end
+
+  def ==(other_address)
+    self_attrs = self.attributes
+    other_attrs = other_address.respond_to?(:attributes) ? other_address.attributes : {}
+
+    [self_attrs, other_attrs].each { |attrs| attrs.except!("id", "created_at", "updated_at", "order_id") }
+
+    self_attrs == other_attrs
+  end
+
+  def empty?
+    attributes.except("id", "created_at", "updated_at", "order_id", "country_id").all? {|_,v| v.nil?}
+  end
+end